mono_runtime_object_init (struct MonoObject * this)
{
  struct MonoVTable * D.21299;
  char * D.21302;
  struct MonoClass * D.21303;
  long unsigned int D.21304;
  long unsigned int D.21305;
  struct MonoMethod * method;
  struct MonoClass * klass;

  method = 0B;
  D.21299 = this->vtable;
  klass = D.21299->klass;
  method = mono_class_get_method_from_name (klass, ".ctor", 0);
  if (method == 0B) goto <D.21300>; else goto <D.21301>;
  <D.21300>:
  D.21302 = mono_type_get_full_name (klass);
  monoeg_g_log (0B, 4, "Could not lookup zero argument constructor for class %s", D.21302);
  <D.19481>:
  goto <D.19481>;
  <D.21301>:
  D.21303 = method->klass;
  D.21304 = BIT_FIELD_REF <*D.21303, 64, 256>;
  D.21305 = D.21304 & 8;
  if (D.21305 != 0) goto <D.21306>; else goto <D.21307>;
  <D.21306>:
  this = mono_object_unbox (this);
  <D.21307>:
  mono_runtime_invoke (method, this, 0B, 0B);
}


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

  registered.0 = registered;
  if (registered.0 == 0) goto <D.21309>; else goto <D.21310>;
  <D.21309>:
  if (0 != 0) goto <D.21311>; else goto <D.21312>;
  <D.21311>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 175, "sizeof (main_thread) == sizeof (MonoObject*)");
  <D.21312>:
  D.21313 = mono_gc_make_root_descr_all_refs (1);
  mono_gc_register_root (&main_thread, 8, D.21313);
  registered = 1;
  <D.21310>:
  main_thread = thread;
}


mono_thread_get_main ()
{
  struct MonoThread * D.21314;

  D.21314 = main_thread;
  return D.21314;
}


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;
  long unsigned int D.21320;
  long unsigned int D.21321;
  char * * D.21322;
  char * D.21323;
  int num_main_args.5;
  int i;

  i = 0;
  goto <D.20514>;
  <D.20513>:
  main_args.4 = main_args;
  D.21320 = (long unsigned int) i;
  D.21321 = D.21320 * 8;
  D.21322 = main_args.4 + D.21321;
  D.21323 = *D.21322;
  monoeg_g_free (D.21323);
  i = i + 1;
  <D.20514>:
  num_main_args.5 = num_main_args;
  if (i < num_main_args.5) goto <D.20513>; else goto <D.20515>;
  <D.20515>:
  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)
{
  long unsigned int D.21325;
  long unsigned int D.21326;
  struct MonoException * D.21329;
  struct MonoImage * D.21330;
  long unsigned int D.21331;
  long unsigned int D.21332;
  long unsigned int D.21335;
  struct MonoDomain * D.21338;
  struct MonoException * exc.6;
  struct MonoException * exc.7;
  long unsigned int D.21347;
  _Bool D.21350;
  long int D.21351;
  long int D.21352;
  _Bool D.21359;
  long int D.21360;
  long int D.21361;
  long unsigned int D.21364;
  _Bool D.21369;
  long int D.21370;
  long int D.21371;
  struct MonoException * D.21376;
  struct GHashTable * type_initialization_hash.8;
  struct MonoDomain * D.21380;
  int D.21383;
  _Bool D.21388;
  long int D.21389;
  long int D.21390;
  struct MonoException * D.21395;
  struct CRITICAL_SECTION * D.21396;
  union mono_mutex_t * D.21397;
  _Bool D.21400;
  long int D.21401;
  long int D.21402;
  unsigned int D.21408;
  int D.21410;
  _Bool D.21413;
  long int D.21414;
  long int D.21415;
  long unsigned int D.21418;
  unsigned int D.21419;
  int D.21422;
  _Bool D.21426;
  long int D.21427;
  long int D.21428;
  long unsigned int D.21431;
  struct GHashTable * blocked_thread_hash.9;
  unsigned int D.21433;
  unsigned int D.21434;
  long unsigned int D.21435;
  void * D.21436;
  _Bool D.21439;
  long int D.21440;
  long int D.21441;
  struct MonoImage * D.21450;
  int D.19556;
  int iftmp.10;
  int D.19555;
  const char[7] * D.21455;
  unsigned char D.21456;
  int D.21457;
  unsigned char D.21458;
  int D.21459;
  const unsigned char * D.21464;
  unsigned char D.21465;
  int D.21466;
  const unsigned char * D.21467;
  unsigned char D.21468;
  int D.21469;
  const unsigned char * D.21474;
  unsigned char D.21475;
  int D.21476;
  const unsigned char * D.21477;
  unsigned char D.21478;
  int D.21479;
  const unsigned char * D.21484;
  unsigned char D.21485;
  int D.21486;
  const unsigned char * D.21487;
  unsigned char D.21488;
  int D.21489;
  const char * D.21491;
  int D.19565;
  int iftmp.11;
  int D.19564;
  const char[28] * D.21496;
  unsigned char D.21497;
  int D.21498;
  unsigned char D.21499;
  int D.21500;
  const unsigned char * D.21505;
  unsigned char D.21506;
  int D.21507;
  const unsigned char * D.21508;
  unsigned char D.21509;
  int D.21510;
  const unsigned char * D.21515;
  unsigned char D.21516;
  int D.21517;
  const unsigned char * D.21518;
  unsigned char D.21519;
  int D.21520;
  const unsigned char * D.21525;
  unsigned char D.21526;
  int D.21527;
  const unsigned char * D.21528;
  unsigned char D.21529;
  int D.21530;
  const char * D.21532;
  char D.21536;
  union mono_mutex_t * D.21538;
  _Bool D.21541;
  long int D.21542;
  long int D.21543;
  struct MonoGHashTable * D.21546;
  struct MonoGHashTable * D.21549;
  _Bool D.21552;
  long int D.21553;
  long int D.21554;
  _Bool D.21561;
  long int D.21562;
  long int D.21563;
  _Bool D.21569;
  long int D.21570;
  long int D.21571;
  _Bool D.21576;
  long int D.21577;
  long int D.21578;
  _Bool D.21583;
  long int D.21584;
  long int D.21585;
  const void * D.21590;
  unsigned int D.21591;
  _Bool D.21598;
  long int D.21599;
  long int D.21600;
  struct MonoException * D.21607;
  struct MonoException * exc;
  struct MonoException * exc_to_throw;
  struct MonoMethod * method;
  struct MonoClass * klass;
  gchar * full_name;

  try
    {
      method = 0B;
      D.21325 = BIT_FIELD_REF <*vtable, 64, 320>;
      D.21326 = D.21325 & 33554432;
      if (D.21326 != 0) goto <D.21327>; else goto <D.21328>;
      <D.21327>:
      D.21329 = 0B;
      return D.21329;
      <D.21328>:
      exc = 0B;
      klass = vtable->klass;
      D.21330 = klass->image;
      D.21331 = BIT_FIELD_REF <*D.21330, 64, 192>;
      D.21332 = D.21331 & 274877906944;
      if (D.21332 == 0) goto <D.21333>; else goto <D.21334>;
      <D.21333>:
      D.21330 = klass->image;
      mono_image_check_for_module_cctor (D.21330);
      D.21330 = klass->image;
      D.21331 = BIT_FIELD_REF <*D.21330, 64, 192>;
      D.21335 = D.21331 & 549755813888;
      if (D.21335 != 0) goto <D.21336>; else goto <D.21337>;
      <D.21336>:
      {
        struct MonoClass * module_klass;
        struct MonoVTable * module_vtable;

        D.21330 = klass->image;
        module_klass = mono_class_get (D.21330, 33554433);
        D.21338 = vtable->domain;
        module_vtable = mono_class_vtable_full (D.21338, module_klass, raise_exception);
        if (module_vtable == 0B) goto <D.21339>; else goto <D.21340>;
        <D.21339>:
        D.21329 = 0B;
        return D.21329;
        <D.21340>:
        exc.6 = mono_runtime_class_init_full (module_vtable, raise_exception);
        exc = exc.6;
        exc.7 = exc;
        if (exc.7 != 0B) goto <D.21343>; else goto <D.21344>;
        <D.21343>:
        D.21329 = exc;
        return D.21329;
        <D.21344>:
      }
      <D.21337>:
      <D.21334>:
      method = mono_class_get_cctor (klass);
      if (method != 0B) goto <D.21345>; else goto <D.21346>;
      <D.21345>:
      {
        struct MonoDomain * domain;
        struct TypeInitializationLock * lock;
        guint32 tid;
        int do_initialization;
        struct MonoDomain * last_domain;

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

          ret = pthread_mutex_lock (&type_initialization_section.mutex);
          if (ret != 0) goto <D.21348>; else goto <D.21349>;
          <D.21348>:
          monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
          <D.21349>:
          D.21350 = ret != 0;
          D.21351 = (long int) D.21350;
          D.21352 = __builtin_expect (D.21351, 0);
          if (D.21352 != 0) goto <D.21353>; else goto <D.21354>;
          <D.21353>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 308, "ret == 0");
          <D.21354>:
        }
        D.21325 = BIT_FIELD_REF <*vtable, 64, 320>;
        D.21326 = D.21325 & 33554432;
        if (D.21326 != 0) goto <D.21355>; else goto <D.21356>;
        <D.21355>:
        {
          int ret;

          ret = pthread_mutex_unlock (&type_initialization_section.mutex);
          if (ret != 0) goto <D.21357>; else goto <D.21358>;
          <D.21357>:
          monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
          <D.21358>:
          D.21359 = ret != 0;
          D.21360 = (long int) D.21359;
          D.21361 = __builtin_expect (D.21360, 0);
          if (D.21361 != 0) goto <D.21362>; else goto <D.21363>;
          <D.21362>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 311, "ret == 0");
          <D.21363>:
        }
        D.21329 = 0B;
        return D.21329;
        <D.21356>:
        D.21325 = BIT_FIELD_REF <*vtable, 64, 320>;
        D.21364 = D.21325 & 67108864;
        if (D.21364 != 0) goto <D.21365>; else goto <D.21366>;
        <D.21365>:
        {
          int ret;

          ret = pthread_mutex_unlock (&type_initialization_section.mutex);
          if (ret != 0) goto <D.21367>; else goto <D.21368>;
          <D.21367>:
          monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
          <D.21368>:
          D.21369 = ret != 0;
          D.21370 = (long int) D.21369;
          D.21371 = __builtin_expect (D.21370, 0);
          if (D.21371 != 0) goto <D.21372>; else goto <D.21373>;
          <D.21372>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 315, "ret == 0");
          <D.21373>:
        }
        if (raise_exception != 0) goto <D.21374>; else goto <D.21375>;
        <D.21374>:
        D.21376 = get_type_init_exception_for_vtable (vtable);
        mono_raise_exception (D.21376);
        <D.21375>:
        D.21329 = get_type_init_exception_for_vtable (vtable);
        return D.21329;
        <D.21366>:
        type_initialization_hash.8 = type_initialization_hash;
        lock = monoeg_g_hash_table_lookup (type_initialization_hash.8, vtable);
        if (lock == 0B) goto <D.21378>; else goto <D.21379>;
        <D.21378>:
        D.21380 = mono_domain_get ();
        if (D.21380 != domain) goto <D.21381>; else goto <D.21382>;
        <D.21381>:
        last_domain = mono_domain_get ();
        D.21383 = mono_domain_set (domain, 0);
        if (D.21383 == 0) goto <D.21384>; else goto <D.21385>;
        <D.21384>:
        vtable->initialized = 1;
        {
          int ret;

          ret = pthread_mutex_unlock (&type_initialization_section.mutex);
          if (ret != 0) goto <D.21386>; else goto <D.21387>;
          <D.21386>:
          monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
          <D.21387>:
          D.21388 = ret != 0;
          D.21389 = (long int) D.21388;
          D.21390 = __builtin_expect (D.21389, 0);
          if (D.21390 != 0) goto <D.21391>; else goto <D.21392>;
          <D.21391>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 330, "ret == 0");
          <D.21392>:
        }
        if (raise_exception != 0) goto <D.21393>; else goto <D.21394>;
        <D.21393>:
        D.21395 = mono_get_exception_appdomain_unloaded ();
        mono_raise_exception (D.21395);
        <D.21394>:
        D.21329 = mono_get_exception_appdomain_unloaded ();
        return D.21329;
        <D.21385>:
        <D.21382>:
        lock = monoeg_malloc (64);
        D.21396 = &lock->initialization_section;
        InitializeCriticalSection (D.21396);
        lock->initializing_tid = tid;
        lock->waiting_count = 1;
        lock->done = 0;
        {
          int ret;

          D.21397 = &lock->initialization_section.mutex;
          ret = pthread_mutex_lock (D.21397);
          if (ret != 0) goto <D.21398>; else goto <D.21399>;
          <D.21398>:
          monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
          <D.21399>:
          D.21400 = ret != 0;
          D.21401 = (long int) D.21400;
          D.21402 = __builtin_expect (D.21401, 0);
          if (D.21402 != 0) goto <D.21403>; else goto <D.21404>;
          <D.21403>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 342, "ret == 0");
          <D.21404>:
        }
        type_initialization_hash.8 = type_initialization_hash;
        monoeg_g_hash_table_insert_replace (type_initialization_hash.8, vtable, lock, 0);
        do_initialization = 1;
        goto <D.21405>;
        <D.21379>:
        {
          void * blocked;
          struct TypeInitializationLock * pending_lock;

          D.21408 = lock->initializing_tid;
          if (D.21408 == tid) goto <D.21406>; else goto <D.21409>;
          <D.21409>:
          D.21410 = lock->done;
          if (D.21410 != 0) goto <D.21406>; else goto <D.21407>;
          <D.21406>:
          {
            int ret;

            ret = pthread_mutex_unlock (&type_initialization_section.mutex);
            if (ret != 0) goto <D.21411>; else goto <D.21412>;
            <D.21411>:
            monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
            <D.21412>:
            D.21413 = ret != 0;
            D.21414 = (long int) D.21413;
            D.21415 = __builtin_expect (D.21414, 0);
            if (D.21415 != 0) goto <D.21416>; else goto <D.21417>;
            <D.21416>:
            monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 350, "ret == 0");
            <D.21417>:
          }
          D.21329 = 0B;
          return D.21329;
          <D.21407>:
          D.21408 = lock->initializing_tid;
          D.21418 = (long unsigned int) D.21408;
          blocked = (void *) D.21418;
          goto <D.19546>;
          <D.19545>:
          D.21419 = pending_lock->initializing_tid;
          if (D.21419 == tid) goto <D.21420>; else goto <D.21421>;
          <D.21420>:
          D.21422 = pending_lock->done;
          if (D.21422 == 0) goto <D.21423>; else goto <D.19544>;
          <D.21423>:
          {
            int ret;

            ret = pthread_mutex_unlock (&type_initialization_section.mutex);
            if (ret != 0) goto <D.21424>; else goto <D.21425>;
            <D.21424>:
            monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
            <D.21425>:
            D.21426 = ret != 0;
            D.21427 = (long int) D.21426;
            D.21428 = __builtin_expect (D.21427, 0);
            if (D.21428 != 0) goto <D.21429>; else goto <D.21430>;
            <D.21429>:
            monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 358, "ret == 0");
            <D.21430>:
          }
          D.21329 = 0B;
          return D.21329;
          <D.21421>:
          D.21419 = pending_lock->initializing_tid;
          D.21431 = (long unsigned int) D.21419;
          blocked = (void *) D.21431;
          <D.19546>:
          blocked_thread_hash.9 = blocked_thread_hash;
          pending_lock = monoeg_g_hash_table_lookup (blocked_thread_hash.9, blocked);
          if (pending_lock != 0B) goto <D.19545>; else goto <D.19544>;
          <D.19544>:
          D.21433 = lock->waiting_count;
          D.21434 = D.21433 + 1;
          lock->waiting_count = D.21434;
          blocked_thread_hash.9 = blocked_thread_hash;
          D.21435 = (long unsigned int) tid;
          D.21436 = (void *) D.21435;
          monoeg_g_hash_table_insert_replace (blocked_thread_hash.9, D.21436, lock, 0);
        }
        <D.21405>:
        {
          int ret;

          ret = pthread_mutex_unlock (&type_initialization_section.mutex);
          if (ret != 0) goto <D.21437>; else goto <D.21438>;
          <D.21437>:
          monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
          <D.21438>:
          D.21439 = ret != 0;
          D.21440 = (long int) D.21439;
          D.21441 = __builtin_expect (D.21440, 0);
          if (D.21441 != 0) goto <D.21442>; else goto <D.21443>;
          <D.21442>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 373, "ret == 0");
          <D.21443>:
        }
        if (do_initialization != 0) goto <D.21444>; else goto <D.21445>;
        <D.21444>:
        mono_runtime_invoke (method, 0B, 0B, &exc);
        exc.7 = exc;
        if (exc.7 != 0B) goto <D.21448>; else goto <D.21449>;
        <D.21448>:
        D.21330 = klass->image;
        D.21450 = mono_defaults.corlib;
        if (D.21330 != D.21450) goto <D.21446>; else goto <D.21451>;
        <D.21451>:
        {
          size_t __s1_len;
          size_t __s2_len;

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

            __s2 = klass->name_space;
            D.21455 = "System";
            D.21456 = MEM[(const unsigned char *)D.21455];
            D.21457 = (int) D.21456;
            D.21458 = *__s2;
            D.21459 = (int) D.21458;
            __result = D.21457 - D.21459;
            {
              if (__s2_len != 0) goto <D.21460>; else goto <D.21461>;
              <D.21460>:
              if (__result == 0) goto <D.21462>; else goto <D.21463>;
              <D.21462>:
              D.21464 = &MEM[(void *)"System" + 1B];
              D.21465 = *D.21464;
              D.21466 = (int) D.21465;
              D.21467 = __s2 + 1;
              D.21468 = *D.21467;
              D.21469 = (int) D.21468;
              __result = D.21466 - D.21469;
              if (__s2_len > 1) goto <D.21470>; else goto <D.21471>;
              <D.21470>:
              if (__result == 0) goto <D.21472>; else goto <D.21473>;
              <D.21472>:
              D.21474 = &MEM[(void *)"System" + 2B];
              D.21475 = *D.21474;
              D.21476 = (int) D.21475;
              D.21477 = __s2 + 2;
              D.21478 = *D.21477;
              D.21479 = (int) D.21478;
              __result = D.21476 - D.21479;
              if (__s2_len > 2) goto <D.21480>; else goto <D.21481>;
              <D.21480>:
              if (__result == 0) goto <D.21482>; else goto <D.21483>;
              <D.21482>:
              D.21484 = &MEM[(void *)"System" + 3B];
              D.21485 = *D.21484;
              D.21486 = (int) D.21485;
              D.21487 = __s2 + 3;
              D.21488 = *D.21487;
              D.21489 = (int) D.21488;
              __result = D.21486 - D.21489;
              <D.21483>:
              <D.21481>:
              <D.21473>:
              <D.21471>:
              <D.21463>:
              <D.21461>:
            }
            D.19555 = __result;
          }
          iftmp.10 = -D.19555;
          goto <D.21490>;
          <D.21454>:
          D.21491 = klass->name_space;
          iftmp.10 = __builtin_strcmp (D.21491, "System");
          <D.21490>:
          D.19556 = iftmp.10;
        }
        if (D.19556 != 0) goto <D.21446>; else goto <D.21492>;
        <D.21492>:
        {
          size_t __s1_len;
          size_t __s2_len;

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

            __s2 = klass->name;
            D.21496 = "TypeInitializationException";
            D.21497 = MEM[(const unsigned char *)D.21496];
            D.21498 = (int) D.21497;
            D.21499 = *__s2;
            D.21500 = (int) D.21499;
            __result = D.21498 - D.21500;
            {
              if (__s2_len != 0) goto <D.21501>; else goto <D.21502>;
              <D.21501>:
              if (__result == 0) goto <D.21503>; else goto <D.21504>;
              <D.21503>:
              D.21505 = &MEM[(void *)"TypeInitializationException" + 1B];
              D.21506 = *D.21505;
              D.21507 = (int) D.21506;
              D.21508 = __s2 + 1;
              D.21509 = *D.21508;
              D.21510 = (int) D.21509;
              __result = D.21507 - D.21510;
              if (__s2_len > 1) goto <D.21511>; else goto <D.21512>;
              <D.21511>:
              if (__result == 0) goto <D.21513>; else goto <D.21514>;
              <D.21513>:
              D.21515 = &MEM[(void *)"TypeInitializationException" + 2B];
              D.21516 = *D.21515;
              D.21517 = (int) D.21516;
              D.21518 = __s2 + 2;
              D.21519 = *D.21518;
              D.21520 = (int) D.21519;
              __result = D.21517 - D.21520;
              if (__s2_len > 2) goto <D.21521>; else goto <D.21522>;
              <D.21521>:
              if (__result == 0) goto <D.21523>; else goto <D.21524>;
              <D.21523>:
              D.21525 = &MEM[(void *)"TypeInitializationException" + 3B];
              D.21526 = *D.21525;
              D.21527 = (int) D.21526;
              D.21528 = __s2 + 3;
              D.21529 = *D.21528;
              D.21530 = (int) D.21529;
              __result = D.21527 - D.21530;
              <D.21524>:
              <D.21522>:
              <D.21514>:
              <D.21512>:
              <D.21504>:
              <D.21502>:
            }
            D.19564 = __result;
          }
          iftmp.11 = -D.19564;
          goto <D.21531>;
          <D.21495>:
          D.21532 = klass->name;
          iftmp.11 = __builtin_strcmp (D.21532, "TypeInitializationException");
          <D.21531>:
          D.19565 = iftmp.11;
        }
        if (D.19565 != 0) goto <D.21446>; else goto <D.21447>;
        <D.21446>:
        vtable->init_failed = 1;
        D.21491 = klass->name_space;
        if (D.21491 != 0B) goto <D.21535>; else goto <D.21533>;
        <D.21535>:
        D.21491 = klass->name_space;
        D.21536 = *D.21491;
        if (D.21536 != 0) goto <D.21537>; else goto <D.21533>;
        <D.21537>:
        D.21491 = klass->name_space;
        D.21532 = klass->name;
        full_name = monoeg_g_strdup_printf ("%s.%s", D.21491, D.21532);
        goto <D.21534>;
        <D.21533>:
        D.21532 = klass->name;
        full_name = monoeg_strdup (D.21532);
        <D.21534>:
        exc.7 = exc;
        exc_to_throw = mono_get_exception_type_initialization (full_name, exc.7);
        monoeg_g_free (full_name);
        {
          int ret;

          D.21538 = &domain->lock.mutex;
          ret = pthread_mutex_lock (D.21538);
          if (ret != 0) goto <D.21539>; else goto <D.21540>;
          <D.21539>:
          monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
          <D.21540>:
          D.21541 = ret != 0;
          D.21542 = (long int) D.21541;
          D.21543 = __builtin_expect (D.21542, 0);
          if (D.21543 != 0) goto <D.21544>; else goto <D.21545>;
          <D.21544>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 397, "ret == 0");
          <D.21545>:
        }
        D.21546 = domain->type_init_exception_hash;
        if (D.21546 == 0B) goto <D.21547>; else goto <D.21548>;
        <D.21547>:
        D.21549 = mono_g_hash_table_new_type (mono_aligned_addr_hash, 0B, 2);
        domain->type_init_exception_hash = D.21549;
        <D.21548>:
        D.21546 = domain->type_init_exception_hash;
        mono_g_hash_table_insert (D.21546, klass, exc_to_throw);
        {
          int ret;

          D.21538 = &domain->lock.mutex;
          ret = pthread_mutex_unlock (D.21538);
          if (ret != 0) goto <D.21550>; else goto <D.21551>;
          <D.21550>:
          monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
          <D.21551>:
          D.21552 = ret != 0;
          D.21553 = (long int) D.21552;
          D.21554 = __builtin_expect (D.21553, 0);
          if (D.21554 != 0) goto <D.21555>; else goto <D.21556>;
          <D.21555>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 401, "ret == 0");
          <D.21556>:
        }
        <D.21447>:
        <D.21449>:
        if (last_domain != 0B) goto <D.21557>; else goto <D.21558>;
        <D.21557>:
        mono_domain_set (last_domain, 1);
        <D.21558>:
        lock->done = 1;
        {
          int ret;

          D.21397 = &lock->initialization_section.mutex;
          ret = pthread_mutex_unlock (D.21397);
          if (ret != 0) goto <D.21559>; else goto <D.21560>;
          <D.21559>:
          monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
          <D.21560>:
          D.21561 = ret != 0;
          D.21562 = (long int) D.21561;
          D.21563 = __builtin_expect (D.21562, 0);
          if (D.21563 != 0) goto <D.21564>; else goto <D.21565>;
          <D.21564>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 407, "ret == 0");
          <D.21565>:
        }
        goto <D.21566>;
        <D.21445>:
        {
          int ret;

          D.21397 = &lock->initialization_section.mutex;
          ret = pthread_mutex_lock (D.21397);
          if (ret != 0) goto <D.21567>; else goto <D.21568>;
          <D.21567>:
          monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
          <D.21568>:
          D.21569 = ret != 0;
          D.21570 = (long int) D.21569;
          D.21571 = __builtin_expect (D.21570, 0);
          if (D.21571 != 0) goto <D.21572>; else goto <D.21573>;
          <D.21572>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 410, "ret == 0");
          <D.21573>:
        }
        {
          int ret;

          D.21397 = &lock->initialization_section.mutex;
          ret = pthread_mutex_unlock (D.21397);
          if (ret != 0) goto <D.21574>; else goto <D.21575>;
          <D.21574>:
          monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
          <D.21575>:
          D.21576 = ret != 0;
          D.21577 = (long int) D.21576;
          D.21578 = __builtin_expect (D.21577, 0);
          if (D.21578 != 0) goto <D.21579>; else goto <D.21580>;
          <D.21579>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 411, "ret == 0");
          <D.21580>:
        }
        <D.21566>:
        {
          int ret;

          ret = pthread_mutex_lock (&type_initialization_section.mutex);
          if (ret != 0) goto <D.21581>; else goto <D.21582>;
          <D.21581>:
          monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
          <D.21582>:
          D.21583 = ret != 0;
          D.21584 = (long int) D.21583;
          D.21585 = __builtin_expect (D.21584, 0);
          if (D.21585 != 0) goto <D.21586>; else goto <D.21587>;
          <D.21586>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 414, "ret == 0");
          <D.21587>:
        }
        D.21408 = lock->initializing_tid;
        if (D.21408 != tid) goto <D.21588>; else goto <D.21589>;
        <D.21588>:
        blocked_thread_hash.9 = blocked_thread_hash;
        D.21435 = (long unsigned int) tid;
        D.21590 = (const void *) D.21435;
        monoeg_g_hash_table_remove (blocked_thread_hash.9, D.21590);
        <D.21589>:
        D.21433 = lock->waiting_count;
        D.21591 = D.21433 + 4294967295;
        lock->waiting_count = D.21591;
        D.21433 = lock->waiting_count;
        if (D.21433 == 0) goto <D.21592>; else goto <D.21593>;
        <D.21592>:
        D.21396 = &lock->initialization_section;
        DeleteCriticalSection (D.21396);
        type_initialization_hash.8 = type_initialization_hash;
        monoeg_g_hash_table_remove (type_initialization_hash.8, vtable);
        monoeg_g_free (lock);
        <D.21593>:
        mono_memory_barrier ();
        D.21325 = BIT_FIELD_REF <*vtable, 64, 320>;
        D.21364 = D.21325 & 67108864;
        if (D.21364 == 0) goto <D.21594>; else goto <D.21595>;
        <D.21594>:
        vtable->initialized = 1;
        <D.21595>:
        {
          int ret;

          ret = pthread_mutex_unlock (&type_initialization_section.mutex);
          if (ret != 0) goto <D.21596>; else goto <D.21597>;
          <D.21596>:
          monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
          <D.21597>:
          D.21598 = ret != 0;
          D.21599 = (long int) D.21598;
          D.21600 = __builtin_expect (D.21599, 0);
          if (D.21600 != 0) goto <D.21601>; else goto <D.21602>;
          <D.21601>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 426, "ret == 0");
          <D.21602>:
        }
        D.21325 = BIT_FIELD_REF <*vtable, 64, 320>;
        D.21364 = D.21325 & 67108864;
        if (D.21364 != 0) goto <D.21603>; else goto <D.21604>;
        <D.21603>:
        if (raise_exception != 0) goto <D.21605>; else goto <D.21606>;
        <D.21605>:
        D.21607 = get_type_init_exception_for_vtable (vtable);
        mono_raise_exception (D.21607);
        <D.21606>:
        D.21329 = get_type_init_exception_for_vtable (vtable);
        return D.21329;
        <D.21604>:
      }
      goto <D.21608>;
      <D.21346>:
      vtable->initialized = 1;
      D.21329 = 0B;
      return D.21329;
      <D.21608>:
      D.21329 = 0B;
      return D.21329;
    }
  finally
    {
      exc = {CLOBBER};
    }
}


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

  if (str != 0B) goto <D.21611>; else goto <D.21612>;
  <D.21611>:
  D.21613 = __strdup (str);
  return D.21613;
  <D.21612>:
  D.21613 = 0B;
  return D.21613;
}


mono_memory_barrier ()
{
  __sync_synchronize ();
}


get_type_init_exception_for_vtable (struct MonoVTable * vtable)
{
  long unsigned int D.21615;
  long unsigned int D.21616;
  char * D.21619;
  union mono_mutex_t * D.21620;
  _Bool D.21623;
  long int D.21624;
  long int D.21625;
  struct MonoGHashTable * D.21628;
  _Bool D.21633;
  long int D.21634;
  long int D.21635;
  const char * D.21642;
  char D.21644;
  const char * D.21646;
  struct MonoException * D.21647;
  struct MonoDomain * domain;
  struct MonoClass * klass;
  struct MonoException * ex;
  gchar * full_name;

  domain = vtable->domain;
  klass = vtable->klass;
  D.21615 = BIT_FIELD_REF <*vtable, 64, 320>;
  D.21616 = D.21615 & 67108864;
  if (D.21616 == 0) goto <D.21617>; else goto <D.21618>;
  <D.21617>:
  D.21619 = 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.21619);
  <D.19513>:
  goto <D.19513>;
  <D.21618>:
  ex = 0B;
  {
    int ret;

    D.21620 = &domain->lock.mutex;
    ret = pthread_mutex_lock (D.21620);
    if (ret != 0) goto <D.21621>; else goto <D.21622>;
    <D.21621>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
    <D.21622>:
    D.21623 = ret != 0;
    D.21624 = (long int) D.21623;
    D.21625 = __builtin_expect (D.21624, 0);
    if (D.21625 != 0) goto <D.21626>; else goto <D.21627>;
    <D.21626>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 236, "ret == 0");
    <D.21627>:
  }
  D.21628 = domain->type_init_exception_hash;
  if (D.21628 != 0B) goto <D.21629>; else goto <D.21630>;
  <D.21629>:
  D.21628 = domain->type_init_exception_hash;
  ex = mono_g_hash_table_lookup (D.21628, klass);
  <D.21630>:
  {
    int ret;

    D.21620 = &domain->lock.mutex;
    ret = pthread_mutex_unlock (D.21620);
    if (ret != 0) goto <D.21631>; else goto <D.21632>;
    <D.21631>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.21632>:
    D.21633 = ret != 0;
    D.21634 = (long int) D.21633;
    D.21635 = __builtin_expect (D.21634, 0);
    if (D.21635 != 0) goto <D.21636>; else goto <D.21637>;
    <D.21636>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 239, "ret == 0");
    <D.21637>:
  }
  if (ex == 0B) goto <D.21638>; else goto <D.21639>;
  <D.21638>:
  D.21642 = klass->name_space;
  if (D.21642 != 0B) goto <D.21643>; else goto <D.21640>;
  <D.21643>:
  D.21642 = klass->name_space;
  D.21644 = *D.21642;
  if (D.21644 != 0) goto <D.21645>; else goto <D.21640>;
  <D.21645>:
  D.21642 = klass->name_space;
  D.21646 = klass->name;
  full_name = monoeg_g_strdup_printf ("%s.%s", D.21642, D.21646);
  goto <D.21641>;
  <D.21640>:
  D.21646 = klass->name;
  full_name = monoeg_strdup (D.21646);
  <D.21641>:
  ex = mono_get_exception_type_initialization (full_name, 0B);
  monoeg_g_free (full_name);
  <D.21639>:
  D.21647 = ex;
  return D.21647;
}


mono_release_type_locks (struct MonoInternalThread * thread)
{
  _Bool D.21651;
  long int D.21652;
  long int D.21653;
  struct GHashTable * type_initialization_hash.12;
  long unsigned int D.21657;
  void * D.21658;
  _Bool D.21661;
  long int D.21662;
  long int D.21663;

  {
    int ret;

    ret = pthread_mutex_lock (&type_initialization_section.mutex);
    if (ret != 0) goto <D.21649>; else goto <D.21650>;
    <D.21649>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
    <D.21650>:
    D.21651 = ret != 0;
    D.21652 = (long int) D.21651;
    D.21653 = __builtin_expect (D.21652, 0);
    if (D.21653 != 0) goto <D.21654>; else goto <D.21655>;
    <D.21654>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 469, "ret == 0");
    <D.21655>:
  }
  type_initialization_hash.12 = type_initialization_hash;
  D.21657 = thread->tid;
  D.21658 = (void *) D.21657;
  monoeg_g_hash_table_foreach_remove (type_initialization_hash.12, release_type_locks, D.21658);
  {
    int ret;

    ret = pthread_mutex_unlock (&type_initialization_section.mutex);
    if (ret != 0) goto <D.21659>; else goto <D.21660>;
    <D.21659>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.21660>:
    D.21661 = ret != 0;
    D.21662 = (long int) D.21661;
    D.21663 = __builtin_expect (D.21662, 0);
    if (D.21663 != 0) goto <D.21664>; else goto <D.21665>;
    <D.21664>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 471, "ret == 0");
    <D.21665>:
  }
}


release_type_locks (void * key, void * value, void * user)
{
  unsigned int D.21666;
  long int user.13;
  unsigned int D.21668;
  int D.21671;
  union mono_mutex_t * D.21674;
  _Bool D.21677;
  long int D.21678;
  long int D.21679;
  unsigned int D.21682;
  unsigned int D.21683;
  struct CRITICAL_SECTION * D.21686;
  gboolean D.21687;
  struct MonoVTable * vtable;
  struct TypeInitializationLock * lock;

  vtable = key;
  lock = value;
  D.21666 = lock->initializing_tid;
  user.13 = (long int) user;
  D.21668 = (unsigned int) user.13;
  if (D.21666 == D.21668) goto <D.21669>; else goto <D.21670>;
  <D.21669>:
  D.21671 = lock->done;
  if (D.21671 == 0) goto <D.21672>; else goto <D.21673>;
  <D.21672>:
  lock->done = 1;
  vtable->init_failed = 1;
  {
    int ret;

    D.21674 = &lock->initialization_section.mutex;
    ret = pthread_mutex_unlock (D.21674);
    if (ret != 0) goto <D.21675>; else goto <D.21676>;
    <D.21675>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.21676>:
    D.21677 = ret != 0;
    D.21678 = (long int) D.21677;
    D.21679 = __builtin_expect (D.21678, 0);
    if (D.21679 != 0) goto <D.21680>; else goto <D.21681>;
    <D.21680>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 455, "ret == 0");
    <D.21681>:
  }
  D.21682 = lock->waiting_count;
  D.21683 = D.21682 + 4294967295;
  lock->waiting_count = D.21683;
  D.21682 = lock->waiting_count;
  if (D.21682 == 0) goto <D.21684>; else goto <D.21685>;
  <D.21684>:
  D.21686 = &lock->initialization_section;
  DeleteCriticalSection (D.21686);
  monoeg_g_free (lock);
  D.21687 = 1;
  return D.21687;
  <D.21685>:
  <D.21673>:
  <D.21670>:
  D.21687 = 0;
  return D.21687;
}


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


memcpy (void * restrict __dest, const void * restrict __src, size_t __len)
{
  void * D.21689;
  long unsigned int D.21690;

  D.21690 = __builtin_object_size (__dest, 0);
  D.21689 = __builtin___memcpy_chk (__dest, __src, __len, D.21690);
  return D.21689;
}


mono_get_runtime_callbacks ()
{
  struct MonoRuntimeCallbacks * D.21692;

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


mono_install_trampoline (void * (*MonoTrampoline) (struct MonoMethod *) func)
{
  void * (*<T1e52>) (struct MonoMethod *) iftmp.14;

  if (func != 0B) goto <D.21695>; else goto <D.21696>;
  <D.21695>:
  iftmp.14 = func;
  goto <D.21697>;
  <D.21696>:
  iftmp.14 = default_trampoline;
  <D.21697>:
  arch_create_jit_trampoline = iftmp.14;
}


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

  D.21698 = method;
  return D.21698;
}


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

  if (func != 0B) goto <D.21701>; else goto <D.21702>;
  <D.21701>:
  iftmp.15 = func;
  goto <D.21703>;
  <D.21702>:
  iftmp.15 = default_jump_trampoline;
  <D.21703>:
  arch_create_jump_trampoline = iftmp.15;
}


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

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


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

  if (func != 0B) goto <D.21707>; else goto <D.21708>;
  <D.21707>:
  iftmp.16 = func;
  goto <D.21709>;
  <D.21708>:
  iftmp.16 = default_remoting_trampoline;
  <D.21709>:
  arch_create_remoting_trampoline = iftmp.16;
}


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

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


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

  if (func != 0B) goto <D.21713>; else goto <D.21714>;
  <D.21713>:
  iftmp.17 = func;
  goto <D.21715>;
  <D.21714>:
  iftmp.17 = default_delegate_trampoline;
  <D.21715>:
  arch_create_delegate_trampoline = iftmp.17;
}


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

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


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 * (*<T12f3>) (struct MonoMethod *) default_mono_compile_method.18;
  void * D.21721;

  default_mono_compile_method.18 = default_mono_compile_method;
  if (default_mono_compile_method.18 == 0B) goto <D.21719>; else goto <D.21720>;
  <D.21719>:
  monoeg_g_log (0B, 4, "compile method called on uninitialized runtime");
  <D.19637>:
  goto <D.19637>;
  D.21721 = 0B;
  return D.21721;
  <D.21720>:
  default_mono_compile_method.18 = default_mono_compile_method;
  D.21721 = default_mono_compile_method.18 (method);
  return D.21721;
}


mono_runtime_create_jump_trampoline (struct MonoDomain * domain, struct MonoMethod * method, gboolean add_sync_wrapper)
{
  void * D.21723;
  void * (*<T1e56>) (struct MonoDomain *, struct MonoMethod *, gboolean) arch_create_jump_trampoline.19;

  arch_create_jump_trampoline.19 = arch_create_jump_trampoline;
  D.21723 = arch_create_jump_trampoline.19 (domain, method, add_sync_wrapper);
  return D.21723;
}


mono_runtime_create_delegate_trampoline (struct MonoClass * klass)
{
  void * D.21726;
  void * (*<T1e60>) (struct MonoDomain *, struct MonoClass *) arch_create_delegate_trampoline.20;
  struct MonoDomain * D.21728;

  arch_create_delegate_trampoline.20 = arch_create_delegate_trampoline;
  D.21728 = mono_domain_get ();
  D.21726 = arch_create_delegate_trampoline.20 (D.21728, klass);
  return D.21726;
}


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 (*<T2612>) (struct MonoDomain *, struct MonoMethod *) default_mono_free_method.21;

  default_mono_free_method.21 = default_mono_free_method;
  if (default_mono_free_method.21 != 0B) goto <D.21731>; else goto <D.21732>;
  <D.21731>:
  default_mono_free_method.21 = default_mono_free_method;
  default_mono_free_method.21 (domain, method);
  <D.21732>:
  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.21733;

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


compute_class_bitmap (struct MonoClass * class, gsize * bitmap, int size, int offset, int * max_set, gboolean static_fields)
{
  int D.21737;
  long unsigned int D.21738;
  long unsigned int D.21739;
  int D.21741;
  long unsigned int D.21742;
  long unsigned int D.21743;
  _Bool D.21746;
  long int D.21747;
  long int D.21748;
  long unsigned int D.21751;
  long unsigned int D.21752;
  long unsigned int D.21753;
  long unsigned int D.21754;
  struct MonoImage * D.21757;
  struct MonoImage * D.21758;
  int D.19674;
  int iftmp.22;
  int D.19670;
  const char[10] * D.21764;
  unsigned char D.21765;
  int D.21766;
  unsigned char D.21767;
  int D.21768;
  const unsigned char * D.21773;
  unsigned char D.21774;
  int D.21775;
  const unsigned char * D.21776;
  unsigned char D.21777;
  int D.21778;
  const unsigned char * D.21783;
  unsigned char D.21784;
  int D.21785;
  const unsigned char * D.21786;
  unsigned char D.21787;
  int D.21788;
  const unsigned char * D.21793;
  unsigned char D.21794;
  int D.21795;
  const unsigned char * D.21796;
  unsigned char D.21797;
  int D.21798;
  const char * D.21800;
  int D.21803;
  long unsigned int D.21804;
  gsize * D.21805;
  struct MonoType * D.21808;
  short unsigned int D.21809;
  int D.21810;
  int D.21811;
  int D.21814;
  long unsigned int D.21820;
  long unsigned int D.21821;
  int D.21825;
  long unsigned int D.21828;
  long unsigned int D.21829;
  unsigned int offset.23;
  unsigned char D.21831;
  int D.21832;
  long unsigned int D.21833;
  _Bool D.21834;
  long int D.21835;
  long int D.21836;
  int iftmp.24;
  unsigned int size.25;
  unsigned int max_size.26;
  _Bool D.21846;
  long int D.21847;
  long int D.21848;
  unsigned int D.21851;
  long unsigned int D.21852;
  long unsigned int D.21853;
  gsize * D.21854;
  long unsigned int D.21855;
  int pos.27;
  int D.21857;
  long unsigned int D.21858;
  long unsigned int D.21859;
  int D.21860;
  unsigned int D.21861;
  unsigned int D.21862;
  int D.21863;
  int D.21864;
  unsigned int D.21869;
  long unsigned int D.21870;
  long unsigned int D.21871;
  gsize * D.21872;
  long unsigned int D.21873;
  long unsigned int D.21874;
  long unsigned int D.21875;
  long unsigned int D.21876;
  unsigned int D.21879;
  int D.21880;
  struct MonoClass * D.21881;
  char * D.21882;
  const char * D.21883;
  struct MonoClassField * field;
  struct MonoClass * p;
  guint32 pos;
  int max_size;

  if (static_fields != 0) goto <D.21735>; else goto <D.21736>;
  <D.21735>:
  D.21737 = mono_class_data_size (class);
  D.21738 = (long unsigned int) D.21737;
  D.21739 = D.21738 / 8;
  max_size = (int) D.21739;
  goto <D.21740>;
  <D.21736>:
  D.21741 = class->instance_size;
  D.21742 = (long unsigned int) D.21741;
  D.21743 = D.21742 / 8;
  max_size = (int) D.21743;
  <D.21740>:
  if (max_size > size) goto <D.21744>; else goto <D.21745>;
  <D.21744>:
  D.21746 = offset > 0;
  D.21747 = (long int) D.21746;
  D.21748 = __builtin_expect (D.21747, 0);
  if (D.21748 != 0) goto <D.21749>; else goto <D.21750>;
  <D.21749>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 664, "offset <= 0");
  <D.21750>:
  D.21751 = (long unsigned int) max_size;
  D.21752 = D.21751 + 63;
  D.21753 = D.21752 / 64;
  D.21754 = D.21753 * 8;
  bitmap = monoeg_malloc0 (D.21754);
  size = max_size;
  <D.21745>:
  if (static_fields == 0) goto <D.21755>; else goto <D.21756>;
  <D.21755>:
  D.21757 = class->image;
  D.21758 = mono_defaults.corlib;
  if (D.21757 == D.21758) goto <D.21759>; else goto <D.21760>;
  <D.21759>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = class->name;
      D.21764 = "Ephemeron";
      D.21765 = MEM[(const unsigned char *)D.21764];
      D.21766 = (int) D.21765;
      D.21767 = *__s2;
      D.21768 = (int) D.21767;
      __result = D.21766 - D.21768;
      {
        if (__s1_len != 0) goto <D.21769>; else goto <D.21770>;
        <D.21769>:
        if (__result == 0) goto <D.21771>; else goto <D.21772>;
        <D.21771>:
        D.21773 = &MEM[(void *)"Ephemeron" + 1B];
        D.21774 = *D.21773;
        D.21775 = (int) D.21774;
        D.21776 = __s2 + 1;
        D.21777 = *D.21776;
        D.21778 = (int) D.21777;
        __result = D.21775 - D.21778;
        if (__s1_len > 1) goto <D.21779>; else goto <D.21780>;
        <D.21779>:
        if (__result == 0) goto <D.21781>; else goto <D.21782>;
        <D.21781>:
        D.21783 = &MEM[(void *)"Ephemeron" + 2B];
        D.21784 = *D.21783;
        D.21785 = (int) D.21784;
        D.21786 = __s2 + 2;
        D.21787 = *D.21786;
        D.21788 = (int) D.21787;
        __result = D.21785 - D.21788;
        if (__s1_len > 2) goto <D.21789>; else goto <D.21790>;
        <D.21789>:
        if (__result == 0) goto <D.21791>; else goto <D.21792>;
        <D.21791>:
        D.21793 = &MEM[(void *)"Ephemeron" + 3B];
        D.21794 = *D.21793;
        D.21795 = (int) D.21794;
        D.21796 = __s2 + 3;
        D.21797 = *D.21796;
        D.21798 = (int) D.21797;
        __result = D.21795 - D.21798;
        <D.21792>:
        <D.21790>:
        <D.21782>:
        <D.21780>:
        <D.21772>:
        <D.21770>:
      }
      D.19670 = __result;
    }
    iftmp.22 = D.19670;
    goto <D.21799>;
    <D.21763>:
    D.21800 = class->name;
    iftmp.22 = __builtin_strcmp ("Ephemeron", D.21800);
    <D.21799>:
    D.19674 = iftmp.22;
  }
  if (D.19674 == 0) goto <D.21801>; else goto <D.21802>;
  <D.21801>:
  *max_set = 0;
  D.21803 = size / 8;
  D.21804 = (long unsigned int) D.21803;
  memset (bitmap, 0, D.21804);
  D.21805 = bitmap;
  return D.21805;
  <D.21802>:
  <D.21760>:
  <D.21756>:
  p = class;
  goto <D.19709>;
  <D.19708>:
  {
    void * iter;

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

          if (static_fields != 0) goto <D.21806>; else goto <D.21807>;
          <D.21806>:
          D.21808 = field->type;
          D.21809 = D.21808->attrs;
          D.21810 = (int) D.21809;
          D.21811 = D.21810 & 272;
          if (D.21811 == 0) goto <D.21812>; else goto <D.21813>;
          <D.21812>:
          // predicted unlikely by continue predictor.
          goto <D.19677>;
          <D.21813>:
          D.21808 = field->type;
          D.21809 = D.21808->attrs;
          D.21810 = (int) D.21809;
          D.21814 = D.21810 & 64;
          if (D.21814 != 0) goto <D.21815>; else goto <D.21816>;
          <D.21815>:
          // predicted unlikely by continue predictor.
          goto <D.19677>;
          <D.21816>:
          goto <D.21817>;
          <D.21807>:
          D.21808 = field->type;
          D.21809 = D.21808->attrs;
          D.21810 = (int) D.21809;
          D.21811 = D.21810 & 272;
          if (D.21811 != 0) goto <D.21818>; else goto <D.21819>;
          <D.21818>:
          // predicted unlikely by continue predictor.
          goto <D.19677>;
          <D.21819>:
          <D.21817>:
          D.21808 = field->type;
          D.21820 = BIT_FIELD_REF <*D.21808, 64, 64>;
          D.21821 = D.21820 & 1073741824;
          if (D.21821 != 0) goto <D.19678>; else goto <D.21822>;
          <D.21822>:
          if (static_fields != 0) goto <D.21823>; else goto <D.21824>;
          <D.21823>:
          D.21825 = field->offset;
          if (D.21825 == -1) goto <D.21826>; else goto <D.21827>;
          <D.21826>:
          // predicted unlikely by continue predictor.
          goto <D.19677>;
          <D.21827>:
          <D.21824>:
          D.21825 = field->offset;
          D.21828 = (long unsigned int) D.21825;
          D.21829 = D.21828 / 8;
          pos = (guint32) D.21829;
          offset.23 = (unsigned int) offset;
          pos = pos + offset.23;
          D.21808 = field->type;
          type = mono_type_get_underlying_type (D.21808);
          D.21831 = type->type;
          D.21832 = (int) D.21831;
          switch (D.21832) <default: <D.19704>, case 2: <D.19702>, case 3: <D.19703>, case 4: <D.19692>, case 5: <D.19693>, case 6: <D.19694>, case 7: <D.19695>, case 8: <D.19696>, case 9: <D.19697>, case 10: <D.19698>, case 11: <D.19699>, case 12: <D.19700>, case 13: <D.19701>, case 14: <D.19684>, case 15: <D.19680>, case 17: <D.19690>, case 18: <D.19686>, case 20: <D.19688>, case 21: <D.19689>, case 24: <D.19679>, case 25: <D.19683>, case 27: <D.19681>, case 28: <D.19687>, case 29: <D.19685>>
          <D.19679>:
          <D.19680>:
          <D.19681>:
          goto <D.19682>;
          <D.19683>:
          goto <D.19682>;
          <D.19684>:
          <D.19685>:
          <D.19686>:
          <D.19687>:
          <D.19688>:
          D.21825 = field->offset;
          D.21828 = (long unsigned int) D.21825;
          D.21833 = D.21828 & 7;
          D.21834 = D.21833 != 0;
          D.21835 = (long int) D.21834;
          D.21836 = __builtin_expect (D.21835, 0);
          if (D.21836 != 0) goto <D.21837>; else goto <D.21838>;
          <D.21837>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 722, "(field->offset % sizeof(gpointer)) == 0");
          <D.21838>:
          size.25 = (unsigned int) size;
          if (size.25 <= pos) goto <D.21843>; else goto <D.21840>;
          <D.21843>:
          max_size.26 = (unsigned int) max_size;
          if (max_size.26 < pos) goto <D.21845>; else goto <D.21840>;
          <D.21845>:
          iftmp.24 = 1;
          goto <D.21841>;
          <D.21840>:
          iftmp.24 = 0;
          <D.21841>:
          D.21846 = iftmp.24 != 0;
          D.21847 = (long int) D.21846;
          D.21848 = __builtin_expect (D.21847, 0);
          if (D.21848 != 0) goto <D.21849>; else goto <D.21850>;
          <D.21849>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 724, "pos < size || pos <= max_size");
          <D.21850>:
          D.21851 = pos / 64;
          D.21852 = (long unsigned int) D.21851;
          D.21853 = D.21852 * 8;
          D.21854 = bitmap + D.21853;
          D.21852 = (long unsigned int) D.21851;
          D.21853 = D.21852 * 8;
          D.21854 = bitmap + D.21853;
          D.21855 = *D.21854;
          pos.27 = (int) pos;
          D.21857 = pos.27 & 63;
          D.21858 = 1 << D.21857;
          D.21859 = D.21855 | D.21858;
          *D.21854 = D.21859;
          D.21860 = *max_set;
          D.21861 = (unsigned int) D.21860;
          D.21862 = MAX_EXPR <D.21861, pos>;
          D.21863 = (int) D.21862;
          *max_set = D.21863;
          goto <D.19682>;
          <D.19689>:
          D.21864 = mono_type_generic_inst_is_valuetype (type);
          if (D.21864 == 0) goto <D.21865>; else goto <D.21866>;
          <D.21865>:
          D.21825 = field->offset;
          D.21828 = (long unsigned int) D.21825;
          D.21833 = D.21828 & 7;
          D.21834 = D.21833 != 0;
          D.21835 = (long int) D.21834;
          D.21836 = __builtin_expect (D.21835, 0);
          if (D.21836 != 0) goto <D.21867>; else goto <D.21868>;
          <D.21867>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 730, "(field->offset % sizeof(gpointer)) == 0");
          <D.21868>:
          D.21869 = pos / 64;
          D.21870 = (long unsigned int) D.21869;
          D.21871 = D.21870 * 8;
          D.21872 = bitmap + D.21871;
          D.21870 = (long unsigned int) D.21869;
          D.21871 = D.21870 * 8;
          D.21872 = bitmap + D.21871;
          D.21873 = *D.21872;
          pos.27 = (int) pos;
          D.21857 = pos.27 & 63;
          D.21858 = 1 << D.21857;
          D.21874 = D.21873 | D.21858;
          *D.21872 = D.21874;
          D.21860 = *max_set;
          D.21861 = (unsigned int) D.21860;
          D.21862 = MAX_EXPR <D.21861, pos>;
          D.21863 = (int) D.21862;
          *max_set = D.21863;
          goto <D.19682>;
          <D.21866>:
          <D.19690>:
          {
            struct MonoClass * fclass;

            D.21808 = field->type;
            fclass = mono_class_from_mono_type (D.21808);
            D.21875 = BIT_FIELD_REF <*fclass, 64, 256>;
            D.21876 = D.21875 & 134217728;
            if (D.21876 != 0) goto <D.21877>; else goto <D.21878>;
            <D.21877>:
            D.21879 = pos + 4294967294;
            D.21880 = (int) D.21879;
            compute_class_bitmap (fclass, bitmap, size, D.21880, max_set, 0);
            <D.21878>:
            goto <D.19682>;
          }
          <D.19692>:
          <D.19693>:
          <D.19694>:
          <D.19695>:
          <D.19696>:
          <D.19697>:
          <D.19698>:
          <D.19699>:
          <D.19700>:
          <D.19701>:
          <D.19702>:
          <D.19703>:
          goto <D.19682>;
          <D.19704>:
          D.21831 = type->type;
          D.21832 = (int) D.21831;
          D.21881 = field->parent;
          D.21882 = mono_type_get_full_name (D.21881);
          D.21883 = field->name;
          monoeg_g_log (0B, 4, "compute_class_bitmap: Invalid type %x for field %s:%s\n", D.21832, D.21882, D.21883);
          <D.19705>:
          goto <D.19705>;
          <D.19682>:
        }
        <D.19677>:
        field = mono_class_get_fields (p, &iter);
        if (field != 0B) goto <D.19706>; else goto <D.19678>;
        <D.19678>:
        if (static_fields != 0) goto <D.19707>; else goto <D.21884>;
        <D.21884>:
      }
    finally
      {
        iter = {CLOBBER};
      }
  }
  p = p->parent;
  <D.19709>:
  if (p != 0B) goto <D.19708>; else goto <D.19707>;
  <D.19707>:
  D.21805 = bitmap;
  return D.21805;
}


memset (void * __dest, int __ch, size_t __len)
{
  int D.21891;
  int D.21896;
  void * D.21898;
  long unsigned int D.21899;

  D.21891 = __builtin_constant_p (__len);
  if (D.21891 != 0) goto <D.21892>; else goto <D.21893>;
  <D.21892>:
  if (__len == 0) goto <D.21894>; else goto <D.21895>;
  <D.21894>:
  D.21896 = __builtin_constant_p (__ch);
  if (D.21896 == 0) goto <D.21889>; else goto <D.21897>;
  <D.21897>:
  if (__ch != 0) goto <D.21889>; else goto <D.21890>;
  <D.21889>:
  __warn_memset_zero_len ();
  D.21898 = __dest;
  return D.21898;
  <D.21890>:
  <D.21895>:
  <D.21893>:
  D.21899 = __builtin_object_size (__dest, 0);
  D.21898 = __builtin___memset_chk (__dest, __ch, __len, D.21899);
  return D.21898;
}


mono_string_alloc (int length)
{
  struct MonoString * D.21901;
  struct MonoDomain * D.21902;

  D.21902 = mono_domain_get ();
  D.21901 = mono_string_new_size (D.21902, length);
  return D.21901;
}


mono_class_compute_gc_descriptor (struct MonoClass * class)
{
  int gcj_inited.28;
  struct MonoMethodSignature * D.21907;
  struct MonoMethodSignature * D.21908;
  struct MonoMethodSignature * D.21909;
  struct MonoMethodSignature * D.21910;
  long unsigned int D.21911;
  long unsigned int D.21912;
  long unsigned int D.21915;
  struct MonoClass * D.21918;
  void * D.21921;
  unsigned char D.21923;
  struct MonoClass * D.21926;
  long unsigned int D.21927;
  long unsigned int D.21928;
  unsigned char D.21931;
  _Bool D.21932;
  int D.21933;
  void * D.21934;
  int D.21936;
  long unsigned int D.21937;
  long unsigned int D.21938;
  int D.21939;
  int D.21940;
  long unsigned int D.21941;
  void * D.21942;
  int max_set.29;
  int D.21947;
  int D.21948;
  long unsigned int D.21949;
  void * D.21950;
  int max_set;
  gsize * bitmap;
  gsize default_bitmap[4];
  static gboolean gcj_inited = 0;

  try
    {
      max_set = 0;
      default_bitmap = {};
      gcj_inited.28 = gcj_inited;
      if (gcj_inited.28 == 0) goto <D.21905>; else goto <D.21906>;
      <D.21905>:
      mono_loader_lock ();
      D.21907 = mono_create_icall_signature ("object ptr");
      mono_register_jit_icall (mono_object_new_ptrfree, "mono_object_new_ptrfree", D.21907, 0);
      D.21908 = mono_create_icall_signature ("object ptr");
      mono_register_jit_icall (mono_object_new_ptrfree_box, "mono_object_new_ptrfree_box", D.21908, 0);
      D.21909 = mono_create_icall_signature ("object ptr");
      mono_register_jit_icall (mono_object_new_fast, "mono_object_new_fast", D.21909, 0);
      D.21910 = mono_create_icall_signature ("object int");
      mono_register_jit_icall (mono_string_alloc, "mono_string_alloc", D.21910, 0);
      gcj_inited = 1;
      mono_loader_unlock ();
      <D.21906>:
      D.21911 = BIT_FIELD_REF <*class, 64, 256>;
      D.21912 = D.21911 & 1;
      if (D.21912 == 0) goto <D.21913>; else goto <D.21914>;
      <D.21913>:
      mono_class_init (class);
      <D.21914>:
      D.21911 = BIT_FIELD_REF <*class, 64, 256>;
      D.21915 = D.21911 & 33554432;
      if (D.21915 != 0) goto <D.21916>; else goto <D.21917>;
      <D.21916>:
      return;
      <D.21917>:
      class->gc_descr_inited = 1;
      class->gc_descr = 0B;
      bitmap = &default_bitmap;
      D.21918 = mono_defaults.string_class;
      if (D.21918 == class) goto <D.21919>; else goto <D.21920>;
      <D.21919>:
      D.21921 = mono_gc_make_descr_for_string (bitmap, 2);
      class->gc_descr = D.21921;
      goto <D.21922>;
      <D.21920>:
      D.21923 = class->rank;
      if (D.21923 != 0) goto <D.21924>; else goto <D.21925>;
      <D.21924>:
      D.21926 = class->element_class;
      mono_class_compute_gc_descriptor (D.21926);
      D.21926 = class->element_class;
      D.21927 = BIT_FIELD_REF <*D.21926, 64, 256>;
      D.21928 = D.21927 & 8;
      if (D.21928 == 0) goto <D.21929>; else goto <D.21930>;
      <D.21929>:
      {
        gsize abm;

        try
          {
            abm = 1;
            D.21931 = class->byval_arg.type;
            D.21932 = D.21931 == 29;
            D.21933 = (int) D.21932;
            D.21934 = mono_gc_make_descr_for_array (D.21933, &abm, 1, 8);
            class->gc_descr = D.21934;
          }
        finally
          {
            abm = {CLOBBER};
          }
      }
      goto <D.21935>;
      <D.21930>:
      D.21926 = class->element_class;
      bitmap = compute_class_bitmap (D.21926, &default_bitmap, 256, -2, &max_set, 0);
      D.21931 = class->byval_arg.type;
      D.21932 = D.21931 == 29;
      D.21933 = (int) D.21932;
      D.21936 = mono_array_element_size (class);
      D.21937 = (long unsigned int) D.21936;
      D.21938 = D.21937 / 8;
      D.21939 = (int) D.21938;
      D.21940 = mono_array_element_size (class);
      D.21941 = (long unsigned int) D.21940;
      D.21942 = mono_gc_make_descr_for_array (D.21933, bitmap, D.21939, D.21941);
      class->gc_descr = D.21942;
      if (&default_bitmap != bitmap) goto <D.21943>; else goto <D.21944>;
      <D.21943>:
      monoeg_g_free (bitmap);
      <D.21944>:
      <D.21935>:
      goto <D.21945>;
      <D.21925>:
      bitmap = compute_class_bitmap (class, &default_bitmap, 256, 0, &max_set, 0);
      max_set.29 = max_set;
      D.21947 = max_set.29 + 1;
      D.21948 = class->instance_size;
      D.21949 = (long unsigned int) D.21948;
      D.21950 = mono_gc_make_descr_for_object (bitmap, D.21947, D.21949);
      class->gc_descr = D.21950;
      if (&default_bitmap != bitmap) goto <D.21951>; else goto <D.21952>;
      <D.21951>:
      monoeg_g_free (bitmap);
      <D.21952>:
      <D.21945>:
      <D.21922>:
    }
  finally
    {
      max_set = {CLOBBER};
      default_bitmap = {CLOBBER};
    }
}


mono_object_new_ptrfree_box (struct MonoVTable * vtable)
{
  struct MonoClass * D.21956;
  int D.21957;
  long unsigned int D.21958;
  struct MonoObject * D.21959;
  struct MonoObject * obj;

  D.21956 = vtable->klass;
  D.21957 = D.21956->instance_size;
  D.21958 = (long unsigned int) D.21957;
  obj = mono_gc_alloc_obj (vtable, D.21958);
  D.21959 = obj;
  return D.21959;
}


mono_object_new_ptrfree (struct MonoVTable * vtable)
{
  struct MonoClass * D.21961;
  int D.21962;
  long unsigned int D.21963;
  struct MonoObject * D.21964;
  struct MonoObject * obj;

  D.21961 = vtable->klass;
  D.21962 = D.21961->instance_size;
  D.21963 = (long unsigned int) D.21962;
  obj = mono_gc_alloc_obj (vtable, D.21963);
  D.21964 = obj;
  return D.21964;
}


mono_method_get_imt_slot (struct MonoMethod * method)
{
  long unsigned int D.21966;
  long unsigned int D.21967;
  short unsigned int D.21970;
  int D.21971;
  long unsigned int D.21972;
  long unsigned int D.21973;
  struct MonoClass * D.21974;
  unsigned int D.21975;
  unsigned int D.21976;
  unsigned char D.21979;
  const char * D.21984;
  const char * D.21985;
  const char * D.21986;
  unsigned int D.21987;
  guint32 * D.21988;
  unsigned int D.21989;
  guint32 * D.21990;
  unsigned int D.21991;
  guint32 * D.21992;
  struct MonoType * D.21993;
  unsigned int D.21994;
  int D.21995;
  long unsigned int D.21996;
  long unsigned int D.21997;
  guint32 * D.21998;
  struct MonoType * D.21999;
  unsigned int D.22000;
  unsigned int hashes_count.30;
  unsigned int D.22002;
  unsigned int D.22003;
  unsigned int D.22004;
  unsigned int D.22005;
  unsigned int D.22006;
  unsigned int D.22007;
  unsigned int D.22008;
  unsigned int D.22009;
  unsigned int D.22010;
  unsigned int D.22011;
  unsigned int D.22012;
  unsigned int D.22013;
  unsigned int D.22014;
  unsigned int D.22015;
  unsigned int D.22016;
  unsigned int D.22017;
  guint32 D.22019;
  struct MonoMethodSignature * sig;
  int hashes_count;
  guint32 * hashes_start;
  guint32 * hashes;
  guint32 a;
  guint32 b;
  guint32 c;
  int i;

  D.21966 = BIT_FIELD_REF <*method, 64, 256>;
  D.21967 = D.21966 & 4096;
  if (D.21967 != 0) goto <D.21968>; else goto <D.21969>;
  <D.21968>:
  method = MEM[(struct MonoMethodInflated *)method].declaring;
  <D.21969>:
  sig = mono_method_signature (method);
  D.21970 = sig->param_count;
  D.21971 = (int) D.21970;
  hashes_count = D.21971 + 4;
  D.21972 = (long unsigned int) hashes_count;
  D.21973 = D.21972 * 4;
  hashes_start = malloc (D.21973);
  hashes = hashes_start;
  D.21974 = method->klass;
  D.21975 = D.21974->flags;
  D.21976 = D.21975 & 32;
  if (D.21976 == 0) goto <D.21977>; else goto <D.21978>;
  <D.21977>:
  D.21974 = method->klass;
  D.21979 = D.21974->byval_arg.type;
  if (D.21979 != 19) goto <D.21980>; else goto <D.21981>;
  <D.21980>:
  D.21974 = method->klass;
  D.21979 = D.21974->byval_arg.type;
  if (D.21979 != 30) goto <D.21982>; else goto <D.21983>;
  <D.21982>:
  D.21974 = method->klass;
  D.21984 = D.21974->name_space;
  D.21974 = method->klass;
  D.21985 = D.21974->name;
  D.21986 = method->name;
  monoeg_g_log (0B, 4, "mono_method_get_imt_slot: %s.%s.%s is not an interface MonoMethod", D.21984, D.21985, D.21986);
  <D.19768>:
  goto <D.19768>;
  <D.21983>:
  <D.21981>:
  <D.21978>:
  D.21974 = method->klass;
  D.21985 = D.21974->name;
  D.21987 = mono_metadata_str_hash (D.21985);
  *hashes = D.21987;
  D.21988 = hashes + 4;
  D.21974 = method->klass;
  D.21984 = D.21974->name_space;
  D.21989 = mono_metadata_str_hash (D.21984);
  *D.21988 = D.21989;
  D.21990 = hashes + 8;
  D.21986 = method->name;
  D.21991 = mono_metadata_str_hash (D.21986);
  *D.21990 = D.21991;
  D.21992 = hashes + 12;
  D.21993 = sig->ret;
  D.21994 = mono_metadata_type_hash (D.21993);
  *D.21992 = D.21994;
  i = 0;
  goto <D.19770>;
  <D.19769>:
  D.21995 = i + 4;
  D.21996 = (long unsigned int) D.21995;
  D.21997 = D.21996 * 4;
  D.21998 = hashes + D.21997;
  D.21999 = sig->params[i];
  D.22000 = mono_metadata_type_hash (D.21999);
  *D.21998 = D.22000;
  i = i + 1;
  <D.19770>:
  D.21970 = sig->param_count;
  D.21971 = (int) D.21970;
  if (D.21971 > i) goto <D.19769>; else goto <D.19771>;
  <D.19771>:
  hashes_count.30 = (unsigned int) hashes_count;
  D.22002 = hashes_count.30 << 2;
  c = D.22002 + 3735928559;
  b = c;
  a = b;
  goto <D.19773>;
  <D.19772>:
  D.22003 = *hashes;
  a = D.22003 + a;
  D.21988 = hashes + 4;
  D.22004 = *D.21988;
  b = D.22004 + b;
  D.21990 = hashes + 8;
  D.22005 = *D.21990;
  c = D.22005 + c;
  a = a - c;
  D.22006 = c r>> 28;
  a = D.22006 ^ a;
  c = c + b;
  b = b - a;
  D.22007 = a r>> 26;
  b = D.22007 ^ b;
  a = a + c;
  c = c - b;
  D.22008 = b r>> 24;
  c = D.22008 ^ c;
  b = b + a;
  a = a - c;
  D.22009 = c r>> 16;
  a = D.22009 ^ a;
  c = c + b;
  b = b - a;
  D.22010 = a r>> 13;
  b = D.22010 ^ b;
  a = a + c;
  c = c - b;
  D.22011 = b r>> 28;
  c = D.22011 ^ c;
  b = b + a;
  hashes_count = hashes_count + -3;
  hashes = hashes + 12;
  <D.19773>:
  if (hashes_count > 3) goto <D.19772>; else goto <D.19774>;
  <D.19774>:
  switch (hashes_count) <default: <D.22018>, case 0: <D.19778>, case 1: <D.19777>, case 2: <D.19776>, case 3: <D.19775>>
  <D.19775>:
  D.21990 = hashes + 8;
  D.22005 = *D.21990;
  c = D.22005 + c;
  <D.19776>:
  D.21988 = hashes + 4;
  D.22004 = *D.21988;
  b = D.22004 + b;
  <D.19777>:
  D.22003 = *hashes;
  a = D.22003 + a;
  c = c ^ b;
  D.22012 = b r>> 18;
  c = c - D.22012;
  a = a ^ c;
  D.22013 = c r>> 21;
  a = a - D.22013;
  b = b ^ a;
  D.22014 = a r>> 7;
  b = b - D.22014;
  c = c ^ b;
  D.22015 = b r>> 16;
  c = c - D.22015;
  a = a ^ c;
  D.22006 = c r>> 28;
  a = a - D.22006;
  b = b ^ a;
  D.22016 = a r>> 18;
  b = b - D.22016;
  c = c ^ b;
  D.22017 = b r>> 8;
  c = c - D.22017;
  <D.19778>:
  goto <D.19779>;
  <D.22018>:
  <D.19779>:
  free (hashes_start);
  D.22019 = c % 19;
  return D.22019;
}


mono_vtable_build_imt_slot (struct MonoVTable * vtable, int imt_slot)
{
  unsigned int imt_slot.31;
  _Bool D.22022;
  long int D.22023;
  long int D.22024;
  struct MonoDomain * D.22027;
  union mono_mutex_t * D.22028;
  _Bool D.22031;
  long int D.22032;
  long int D.22033;
  long unsigned int D.22036;
  long unsigned int D.22037;
  void * * D.22038;
  void * D.22039;
  void * (*<T25d8>) (int) D.22040;
  void * D.22041;
  struct MonoClass * D.22044;
  _Bool D.22047;
  long int D.22048;
  long int D.22049;
  void * * imt;

  imt = vtable;
  imt = imt + 18446744073709551464;
  imt_slot.31 = (unsigned int) imt_slot;
  D.22022 = imt_slot.31 > 18;
  D.22023 = (long int) D.22022;
  D.22024 = __builtin_expect (D.22023, 0);
  if (D.22024 != 0) goto <D.22025>; else goto <D.22026>;
  <D.22025>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 1452, "imt_slot >= 0 && imt_slot < MONO_IMT_SIZE");
  <D.22026>:
  mono_loader_lock ();
  {
    int ret;

    D.22027 = vtable->domain;
    D.22028 = &D.22027->lock.mutex;
    ret = pthread_mutex_lock (D.22028);
    if (ret != 0) goto <D.22029>; else goto <D.22030>;
    <D.22029>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
    <D.22030>:
    D.22031 = ret != 0;
    D.22032 = (long int) D.22031;
    D.22033 = __builtin_expect (D.22032, 0);
    if (D.22033 != 0) goto <D.22034>; else goto <D.22035>;
    <D.22034>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 1460, "ret == 0");
    <D.22035>:
  }
  D.22036 = (long unsigned int) imt_slot;
  D.22037 = D.22036 * 8;
  D.22038 = imt + D.22037;
  D.22039 = *D.22038;
  D.22040 = callbacks.get_imt_trampoline;
  D.22041 = D.22040 (imt_slot);
  if (D.22039 == D.22041) goto <D.22042>; else goto <D.22043>;
  <D.22042>:
  D.22044 = vtable->klass;
  D.22027 = vtable->domain;
  build_imt_slots (D.22044, vtable, D.22027, imt, 0B, imt_slot);
  <D.22043>:
  {
    int ret;

    D.22027 = vtable->domain;
    D.22028 = &D.22027->lock.mutex;
    ret = pthread_mutex_unlock (D.22028);
    if (ret != 0) goto <D.22045>; else goto <D.22046>;
    <D.22045>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.22046>:
    D.22047 = ret != 0;
    D.22048 = (long int) D.22047;
    D.22049 = __builtin_expect (D.22048, 0);
    if (D.22049 != 0) goto <D.22050>; else goto <D.22051>;
    <D.22050>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 1464, "ret == 0");
    <D.22051>:
  }
  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.22052;
  long unsigned int D.22053;
  long unsigned int D.22054;
  struct MonoClass * * D.22055;
  guint16 * D.22056;
  long unsigned int D.22057;
  guint16 * D.22058;
  short unsigned int D.22059;
  int D.22060;
  long unsigned int D.22065;
  long unsigned int D.22066;
  struct MonoGenericClass * D.22069;
  struct MonoClass * D.22070;
  unsigned int D.22071;
  unsigned int slot_num.32;
  long unsigned int D.22075;
  long unsigned int D.22076;
  short unsigned int D.22079;
  int D.22080;
  int D.22081;
  unsigned int method_slot_in_interface.33;
  unsigned int D.22085;
  short unsigned int D.22086;
  int D.22087;
  int D.22090;
  unsigned int method_slot_in_interface.34;
  unsigned int D.22092;
  unsigned int interface_offset.35;
  unsigned int D.22094;
  void * * D.22098;
  struct MonoImtBuilderEntry * * D.22101;
  struct MonoImtBuilderEntry * D.22102;
  struct _MonoImtBuilderEntry * D.22105;
  int D.22106;
  int D.22107;
  int D.22108;
  int D.22109;
  int D.22110;
  int D.22113;
  unsigned int D.22114;
  unsigned int imt_collisions_bitmap.36;
  unsigned int imt_collisions_bitmap.37;
  void * iftmp.38;
  void * (*<T25d8>) (int) D.22118;
  void * D.22122;
  void * D.22124;
  long unsigned int D.22127;
  long unsigned int D.22128;
  long unsigned int D.22131;
  long unsigned int D.22132;
  long unsigned int D.22133;
  unsigned int D.22136;
  unsigned int D.22137;
  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, 8);
      method_count = 0;
      record_method_count_for_max_collisions = 0;
      has_generic_virtual = 0;
      has_variant_iface = 0;
      i = 0;
      goto <D.19862>;
      <D.19861>:
      {
        struct MonoClass * iface;
        int interface_offset;
        int method_slot_in_interface;
        int vt_slot;

        D.22052 = klass->interfaces_packed;
        D.22053 = (long unsigned int) i;
        D.22054 = D.22053 * 8;
        D.22055 = D.22052 + D.22054;
        iface = *D.22055;
        D.22056 = klass->interface_offsets_packed;
        D.22053 = (long unsigned int) i;
        D.22057 = D.22053 * 2;
        D.22058 = D.22056 + D.22057;
        D.22059 = *D.22058;
        interface_offset = (int) D.22059;
        D.22060 = mono_class_has_variant_generic_params (iface);
        if (D.22060 != 0) goto <D.22061>; else goto <D.22062>;
        <D.22061>:
        has_variant_iface = 1;
        <D.22062>:
        mono_class_setup_methods (iface);
        vt_slot = interface_offset;
        method_slot_in_interface = 0;
        goto <D.19859>;
        <D.19858>:
        {
          struct MonoMethod * method;

          if (slot_num >= 0) goto <D.22063>; else goto <D.22064>;
          <D.22063>:
          D.22065 = BIT_FIELD_REF <*iface, 64, 256>;
          D.22066 = D.22065 & 34359738368;
          if (D.22066 != 0) goto <D.22067>; else goto <D.22068>;
          <D.22067>:
          D.22069 = iface->generic_class;
          D.22070 = D.22069->container_class;
          method = mono_class_get_method_by_index (D.22070, method_slot_in_interface);
          D.22071 = mono_method_get_imt_slot (method);
          slot_num.32 = (unsigned int) slot_num;
          if (D.22071 != slot_num.32) goto <D.22073>; else goto <D.22074>;
          <D.22073>:
          vt_slot = vt_slot + 1;
          // predicted unlikely by continue predictor.
          goto <D.19857>;
          <D.22074>:
          <D.22068>:
          <D.22064>:
          method = mono_class_get_method_by_index (iface, method_slot_in_interface);
          D.22075 = BIT_FIELD_REF <*method, 64, 256>;
          D.22076 = D.22075 & 2048;
          if (D.22076 != 0) goto <D.22077>; else goto <D.22078>;
          <D.22077>:
          has_generic_virtual = 1;
          vt_slot = vt_slot + 1;
          // predicted unlikely by continue predictor.
          goto <D.19857>;
          <D.22078>:
          D.22079 = method->flags;
          D.22080 = (int) D.22079;
          D.22081 = D.22080 & 16;
          if (D.22081 == 0) goto <D.22082>; else goto <D.22083>;
          <D.22082>:
          add_imt_builder_entry (imt_builder, method, &imt_collisions_bitmap, vt_slot, slot_num);
          vt_slot = vt_slot + 1;
          <D.22083>:
        }
        <D.19857>:
        method_slot_in_interface = method_slot_in_interface + 1;
        <D.19859>:
        method_slot_in_interface.33 = (unsigned int) method_slot_in_interface;
        D.22085 = iface->method.count;
        if (method_slot_in_interface.33 < D.22085) goto <D.19858>; else goto <D.19860>;
        <D.19860>:
      }
      i = i + 1;
      <D.19862>:
      D.22086 = klass->interface_offsets_count;
      D.22087 = (int) D.22086;
      if (D.22087 > i) goto <D.19861>; else goto <D.19863>;
      <D.19863>:
      if (extra_interfaces != 0B) goto <D.22088>; else goto <D.22089>;
      <D.22088>:
      {
        int interface_offset;

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

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

            method = mono_class_get_method_by_index (iface, method_slot_in_interface);
            D.22090 = interface_offset + method_slot_in_interface;
            add_imt_builder_entry (imt_builder, method, &imt_collisions_bitmap, D.22090, slot_num);
          }
          method_slot_in_interface = method_slot_in_interface + 1;
          <D.19869>:
          method_slot_in_interface.34 = (unsigned int) method_slot_in_interface;
          D.22092 = iface->method.count;
          if (method_slot_in_interface.34 < D.22092) goto <D.19868>; else goto <D.19870>;
          <D.19870>:
          D.22092 = iface->method.count;
          interface_offset.35 = (unsigned int) interface_offset;
          D.22094 = D.22092 + interface_offset.35;
          interface_offset = (int) D.22094;
        }
        list_item = list_item->next;
        <D.19872>:
        if (list_item != 0B) goto <D.19871>; else goto <D.19873>;
        <D.19873>:
      }
      <D.22089>:
      i = 0;
      goto <D.19881>;
      <D.19880>:
      if (slot_num < 0) goto <D.22095>; else goto <D.22097>;
      <D.22097>:
      if (i == slot_num) goto <D.22095>; else goto <D.22096>;
      <D.22095>:
      {
        struct MonoImtBuilderEntry * entries;

        D.22053 = (long unsigned int) i;
        D.22054 = D.22053 * 8;
        D.22098 = imt + D.22054;
        entries = get_generic_virtual_entries (domain, D.22098);
        if (entries != 0B) goto <D.22099>; else goto <D.22100>;
        <D.22099>:
        D.22053 = (long unsigned int) i;
        D.22054 = D.22053 * 8;
        D.22101 = imt_builder + D.22054;
        D.22102 = *D.22101;
        if (D.22102 != 0B) goto <D.22103>; else goto <D.22104>;
        <D.22103>:
        {
          struct MonoImtBuilderEntry * entry;

          entry = entries;
          goto <D.19877>;
          <D.19876>:
          entry = entry->next;
          <D.19877>:
          D.22105 = entry->next;
          if (D.22105 != 0B) goto <D.19876>; else goto <D.19878>;
          <D.19878>:
          D.22053 = (long unsigned int) i;
          D.22054 = D.22053 * 8;
          D.22101 = imt_builder + D.22054;
          D.22102 = *D.22101;
          entry->next = D.22102;
          D.22106 = entries->children;
          D.22053 = (long unsigned int) i;
          D.22054 = D.22053 * 8;
          D.22101 = imt_builder + D.22054;
          D.22102 = *D.22101;
          D.22107 = D.22102->children;
          D.22108 = D.22107 + 1;
          D.22109 = D.22106 + D.22108;
          entries->children = D.22109;
        }
        <D.22104>:
        D.22053 = (long unsigned int) i;
        D.22054 = D.22053 * 8;
        D.22101 = imt_builder + D.22054;
        *D.22101 = entries;
        <D.22100>:
        D.22110 = has_generic_virtual | has_variant_iface;
        if (D.22110 != 0) goto <D.22111>; else goto <D.22112>;
        <D.22111>:
        D.22113 = 1 << i;
        D.22114 = (unsigned int) D.22113;
        imt_collisions_bitmap.36 = imt_collisions_bitmap;
        imt_collisions_bitmap.37 = D.22114 | imt_collisions_bitmap.36;
        imt_collisions_bitmap = imt_collisions_bitmap.37;
        D.22053 = (long unsigned int) i;
        D.22054 = D.22053 * 8;
        D.22098 = imt + D.22054;
        D.22053 = (long unsigned int) i;
        D.22054 = D.22053 * 8;
        D.22101 = imt_builder + D.22054;
        D.22102 = *D.22101;
        D.22118 = callbacks.get_imt_trampoline;
        if (D.22118 != 0B) goto <D.22119>; else goto <D.22120>;
        <D.22119>:
        D.22118 = callbacks.get_imt_trampoline;
        iftmp.38 = D.22118 (i);
        goto <D.22121>;
        <D.22120>:
        iftmp.38 = 0B;
        <D.22121>:
        D.22122 = initialize_imt_slot (vt, domain, D.22102, iftmp.38);
        *D.22098 = D.22122;
        goto <D.22123>;
        <D.22112>:
        D.22053 = (long unsigned int) i;
        D.22054 = D.22053 * 8;
        D.22098 = imt + D.22054;
        D.22053 = (long unsigned int) i;
        D.22054 = D.22053 * 8;
        D.22101 = imt_builder + D.22054;
        D.22102 = *D.22101;
        D.22124 = initialize_imt_slot (vt, domain, D.22102, 0B);
        *D.22098 = D.22124;
        <D.22123>:
      }
      <D.22096>:
      D.22053 = (long unsigned int) i;
      D.22054 = D.22053 * 8;
      D.22101 = imt_builder + D.22054;
      D.22102 = *D.22101;
      if (D.22102 != 0B) goto <D.22125>; else goto <D.22126>;
      <D.22125>:
      {
        int methods_in_slot;

        D.22053 = (long unsigned int) i;
        D.22054 = D.22053 * 8;
        D.22101 = imt_builder + D.22054;
        D.22102 = *D.22101;
        D.22107 = D.22102->children;
        methods_in_slot = D.22107 + 1;
        D.22127 = (long unsigned int) methods_in_slot;
        D.22128 = mono_stats.imt_max_collisions_in_slot;
        if (D.22127 > D.22128) goto <D.22129>; else goto <D.22130>;
        <D.22129>:
        D.22127 = (long unsigned int) methods_in_slot;
        mono_stats.imt_max_collisions_in_slot = D.22127;
        record_method_count_for_max_collisions = 1;
        <D.22130>:
        method_count = method_count + methods_in_slot;
      }
      <D.22126>:
      i = i + 1;
      <D.19881>:
      if (i <= 18) goto <D.19880>; else goto <D.19882>;
      <D.19882>:
      D.22131 = mono_stats.imt_number_of_methods;
      D.22132 = (long unsigned int) method_count;
      D.22133 = D.22131 + D.22132;
      mono_stats.imt_number_of_methods = D.22133;
      if (record_method_count_for_max_collisions != 0) goto <D.22134>; else goto <D.22135>;
      <D.22134>:
      D.22132 = (long unsigned int) method_count;
      mono_stats.imt_method_count_when_max_collisions = D.22132;
      <D.22135>:
      i = 0;
      goto <D.19889>;
      <D.19888>:
      {
        struct MonoImtBuilderEntry * entry;

        D.22053 = (long unsigned int) i;
        D.22054 = D.22053 * 8;
        D.22101 = imt_builder + D.22054;
        entry = *D.22101;
        goto <D.19886>;
        <D.19885>:
        {
          struct MonoImtBuilderEntry * next;

          next = entry->next;
          monoeg_g_free (entry);
          entry = next;
        }
        <D.19886>:
        if (entry != 0B) goto <D.19885>; else goto <D.19887>;
        <D.19887>:
      }
      i = i + 1;
      <D.19889>:
      if (i <= 18) goto <D.19888>; else goto <D.19890>;
      <D.19890>:
      free (imt_builder);
      D.22136 = vt->imt_collisions_bitmap;
      imt_collisions_bitmap.36 = imt_collisions_bitmap;
      D.22137 = D.22136 | imt_collisions_bitmap.36;
      vt->imt_collisions_bitmap = D.22137;
    }
  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.39;
  long unsigned int D.22143;
  long unsigned int D.22144;
  struct MonoImtBuilderEntry * * D.22145;
  struct MonoImtBuilderEntry * D.22146;
  int D.22149;
  int D.22150;
  int D.22151;
  long unsigned int D.22154;
  long unsigned int D.22155;
  unsigned int D.22156;
  int imt_slot.40;
  int D.22158;
  unsigned int D.22159;
  unsigned int D.22160;
  long unsigned int D.22162;
  long unsigned int D.22163;
  guint32 imt_slot;
  struct MonoImtBuilderEntry * entry;

  imt_slot = mono_method_get_imt_slot (method);
  if (slot_num >= 0) goto <D.22138>; else goto <D.22139>;
  <D.22138>:
  slot_num.39 = (unsigned int) slot_num;
  if (slot_num.39 != imt_slot) goto <D.22141>; else goto <D.22142>;
  <D.22141>:
  return;
  <D.22142>:
  <D.22139>:
  entry = monoeg_malloc0 (32);
  entry->key = method;
  entry->value.vtable_slot = vtable_slot;
  D.22143 = (long unsigned int) imt_slot;
  D.22144 = D.22143 * 8;
  D.22145 = imt_builder + D.22144;
  D.22146 = *D.22145;
  entry->next = D.22146;
  D.22143 = (long unsigned int) imt_slot;
  D.22144 = D.22143 * 8;
  D.22145 = imt_builder + D.22144;
  D.22146 = *D.22145;
  if (D.22146 != 0B) goto <D.22147>; else goto <D.22148>;
  <D.22147>:
  D.22143 = (long unsigned int) imt_slot;
  D.22144 = D.22143 * 8;
  D.22145 = imt_builder + D.22144;
  D.22146 = *D.22145;
  D.22149 = D.22146->children;
  D.22150 = D.22149 + 1;
  entry->children = D.22150;
  D.22151 = entry->children;
  if (D.22151 == 1) goto <D.22152>; else goto <D.22153>;
  <D.22152>:
  D.22154 = mono_stats.imt_slots_with_collisions;
  D.22155 = D.22154 + 1;
  mono_stats.imt_slots_with_collisions = D.22155;
  D.22156 = *imt_collisions_bitmap;
  imt_slot.40 = (int) imt_slot;
  D.22158 = 1 << imt_slot.40;
  D.22159 = (unsigned int) D.22158;
  D.22160 = D.22156 | D.22159;
  *imt_collisions_bitmap = D.22160;
  <D.22153>:
  goto <D.22161>;
  <D.22148>:
  entry->children = 0;
  D.22162 = mono_stats.imt_used_slots;
  D.22163 = D.22162 + 1;
  mono_stats.imt_used_slots = D.22163;
  <D.22161>:
  D.22143 = (long unsigned int) imt_slot;
  D.22144 = D.22143 * 8;
  D.22145 = imt_builder + D.22144;
  *D.22145 = entry;
}


get_generic_virtual_entries (struct MonoDomain * domain, void * * vtable_slot)
{
  union mono_mutex_t * D.22165;
  _Bool D.22168;
  long int D.22169;
  long int D.22170;
  struct GHashTable * D.22173;
  struct GHashTable * D.22176;
  int D.22177;
  struct MonoMethod * D.22180;
  void * D.22181;
  void * D.22182;
  int D.22185;
  int D.22186;
  _Bool D.22189;
  long int D.22190;
  long int D.22191;
  struct MonoImtBuilderEntry * D.22194;
  struct GenericVirtualCase * list;
  struct MonoImtBuilderEntry * entries;

  {
    int ret;

    D.22165 = &domain->lock.mutex;
    ret = pthread_mutex_lock (D.22165);
    if (ret != 0) goto <D.22166>; else goto <D.22167>;
    <D.22166>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
    <D.22167>:
    D.22168 = ret != 0;
    D.22169 = (long int) D.22168;
    D.22170 = __builtin_expect (D.22169, 0);
    if (D.22170 != 0) goto <D.22171>; else goto <D.22172>;
    <D.22171>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 1645, "ret == 0");
    <D.22172>:
  }
  D.22173 = domain->generic_virtual_cases;
  if (D.22173 == 0B) goto <D.22174>; else goto <D.22175>;
  <D.22174>:
  D.22176 = monoeg_g_hash_table_new (mono_aligned_addr_hash, 0B);
  domain->generic_virtual_cases = D.22176;
  <D.22175>:
  D.22173 = domain->generic_virtual_cases;
  list = monoeg_g_hash_table_lookup (D.22173, vtable_slot);
  entries = 0B;
  goto <D.19966>;
  <D.19965>:
  {
    struct MonoImtBuilderEntry * entry;

    D.22177 = list->count;
    if (D.22177 <= 9) goto <D.22178>; else goto <D.22179>;
    <D.22178>:
    // predicted unlikely by continue predictor.
    goto <D.19964>;
    <D.22179>:
    entry = monoeg_malloc0 (32);
    D.22180 = list->method;
    entry->key = D.22180;
    D.22181 = list->code;
    D.22182 = mono_get_addr_from_ftnptr (D.22181);
    entry->value.target_code = D.22182;
    entry->has_target_code = 1;
    if (entries != 0B) goto <D.22183>; else goto <D.22184>;
    <D.22183>:
    D.22185 = entries->children;
    D.22186 = D.22185 + 1;
    entry->children = D.22186;
    <D.22184>:
    entry->next = entries;
    entries = entry;
  }
  <D.19964>:
  list = list->next;
  <D.19966>:
  if (list != 0B) goto <D.19965>; else goto <D.19967>;
  <D.19967>:
  {
    int ret;

    D.22165 = &domain->lock.mutex;
    ret = pthread_mutex_unlock (D.22165);
    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", 1668, "ret == 0");
    <D.22193>:
  }
  D.22194 = entries;
  return D.22194;
}


initialize_imt_slot (struct MonoVTable * vtable, struct MonoDomain * domain, struct MonoImtBuilderEntry * imt_builder_entry, void * fail_tramp)
{
  int D.22199;
  void * D.22202;
  int D.22203;
  void * (*<T2810>) (struct MonoVTable *, struct MonoDomain *, struct MonoIMTCheckItem * *, int, void *) imt_thunk_builder.41;
  void * * D.22205;
  unsigned int D.22206;
  int D.22207;
  long unsigned int D.22208;
  long unsigned int D.22209;
  void * * D.22210;
  void * D.22211;
  unsigned int i.42;

  if (imt_builder_entry != 0B) goto <D.22196>; else goto <D.22197>;
  <D.22196>:
  D.22199 = imt_builder_entry->children;
  if (D.22199 == 0) goto <D.22200>; else goto <D.22198>;
  <D.22200>:
  if (fail_tramp == 0B) goto <D.22201>; else goto <D.22198>;
  <D.22201>:
  D.22203 = imt_builder_entry->value.vtable_slot;
  D.22202 = vtable->vtable[D.22203];
  return D.22202;
  <D.22198>:
  {
    struct GPtrArray * imt_ir;
    void * result;
    int i;

    imt_ir = imt_sort_slot_entries (imt_builder_entry);
    imt_thunk_builder.41 = imt_thunk_builder;
    D.22205 = imt_ir->pdata;
    D.22206 = imt_ir->len;
    D.22207 = (int) D.22206;
    result = imt_thunk_builder.41 (vtable, domain, D.22205, D.22207, fail_tramp);
    i = 0;
    goto <D.19831>;
    <D.19830>:
    D.22205 = imt_ir->pdata;
    D.22208 = (long unsigned int) i;
    D.22209 = D.22208 * 8;
    D.22210 = D.22205 + D.22209;
    D.22211 = *D.22210;
    monoeg_g_free (D.22211);
    i = i + 1;
    <D.19831>:
    i.42 = (unsigned int) i;
    D.22206 = imt_ir->len;
    if (i.42 < D.22206) goto <D.19830>; else goto <D.19832>;
    <D.19832>:
    monoeg_g_ptr_array_free (imt_ir, 1);
    D.22202 = result;
    return D.22202;
  }
  <D.22197>:
  if (fail_tramp != 0B) goto <D.22213>; else goto <D.22214>;
  <D.22213>:
  D.22202 = fail_tramp;
  return D.22202;
  <D.22214>:
  D.22202 = 0B;
  return D.22202;
}


imt_sort_slot_entries (struct MonoImtBuilderEntry * entries)
{
  int D.22216;
  long unsigned int D.22217;
  long unsigned int D.22218;
  long unsigned int D.22219;
  long unsigned int D.22220;
  struct MonoImtBuilderEntry * * D.22221;
  long unsigned int D.22222;
  struct GPtrArray * D.22223;
  int number_of_entries;
  struct MonoImtBuilderEntry * * sorted_array;
  struct GPtrArray * result;
  struct MonoImtBuilderEntry * current_entry;
  int i;

  D.22216 = entries->children;
  number_of_entries = D.22216 + 1;
  D.22217 = (long unsigned int) number_of_entries;
  D.22218 = D.22217 * 8;
  sorted_array = malloc (D.22218);
  result = monoeg_g_ptr_array_new ();
  current_entry = entries;
  i = 0;
  goto <D.19819>;
  <D.19818>:
  D.22219 = (long unsigned int) i;
  D.22220 = D.22219 * 8;
  D.22221 = sorted_array + D.22220;
  *D.22221 = current_entry;
  current_entry = current_entry->next;
  i = i + 1;
  <D.19819>:
  if (current_entry != 0B) goto <D.19818>; else goto <D.19820>;
  <D.19820>:
  D.22222 = (long unsigned int) number_of_entries;
  qsort (sorted_array, D.22222, 8, compare_imt_builder_entries);
  imt_emit_ir (sorted_array, 0, number_of_entries, result);
  free (sorted_array);
  D.22223 = result;
  return D.22223;
}


compare_imt_builder_entries (const void * p1, const void * p2)
{
  int D.22225;
  int iftmp.43;
  void * D.22227;
  void * D.22228;
  _Bool D.22231;
  struct MonoImtBuilderEntry * e1;
  struct MonoImtBuilderEntry * e2;

  e1 = MEM[(struct MonoImtBuilderEntry * *)p1];
  e2 = MEM[(struct MonoImtBuilderEntry * *)p2];
  D.22227 = e1->key;
  D.22228 = e2->key;
  if (D.22227 >= D.22228) goto <D.22229>; else goto <D.22230>;
  <D.22229>:
  D.22227 = e1->key;
  D.22228 = e2->key;
  D.22231 = D.22227 > D.22228;
  iftmp.43 = (int) D.22231;
  goto <D.22232>;
  <D.22230>:
  iftmp.43 = -1;
  <D.22232>:
  D.22225 = iftmp.43;
  return D.22225;
}


imt_emit_ir (struct MonoImtBuilderEntry * * sorted_array, int start, int end, struct GPtrArray * out_array)
{
  unsigned int D.22234;
  long unsigned int D.22237;
  long unsigned int D.22238;
  struct MonoImtBuilderEntry * * D.22239;
  struct MonoImtBuilderEntry * D.22240;
  void * D.22241;
  <unnamed-unsigned:1> D.22242;
  unsigned char D.22243;
  int D.22244;
  unsigned int D.22247;
  int D.22248;
  int D.22251;
  long unsigned int D.22252;
  long unsigned int D.22253;
  struct MonoImtBuilderEntry * * D.22254;
  struct MonoImtBuilderEntry * D.22255;
  void * D.22256;
  int D.22257;
  int D.22258;
  int count;
  int chunk_start;

  count = end - start;
  D.22234 = out_array->len;
  chunk_start = (int) D.22234;
  if (count <= 3) goto <D.22235>; else goto <D.22236>;
  <D.22235>:
  {
    int i;

    i = start;
    goto <D.19806>;
    <D.19805>:
    {
      struct MonoIMTCheckItem * item;

      item = monoeg_malloc0 (48);
      D.22237 = (long unsigned int) i;
      D.22238 = D.22237 * 8;
      D.22239 = sorted_array + D.22238;
      D.22240 = *D.22239;
      D.22241 = D.22240->key;
      item->key = D.22241;
      D.22237 = (long unsigned int) i;
      D.22238 = D.22237 * 8;
      D.22239 = sorted_array + D.22238;
      D.22240 = *D.22239;
      item->value = D.22240->value;
      D.22237 = (long unsigned int) i;
      D.22238 = D.22237 * 8;
      D.22239 = sorted_array + D.22238;
      D.22240 = *D.22239;
      D.22242 = D.22240->has_target_code;
      D.22243 = (unsigned char) D.22242;
      item->has_target_code = D.22243;
      item->is_equals = 1;
      D.22244 = end + -1;
      if (D.22244 > i) goto <D.22245>; else goto <D.22246>;
      <D.22245>:
      D.22234 = out_array->len;
      D.22247 = D.22234 + 1;
      D.22248 = (int) D.22247;
      item->check_target_idx = D.22248;
      goto <D.22249>;
      <D.22246>:
      item->check_target_idx = 0;
      <D.22249>:
      monoeg_g_ptr_array_add (out_array, item);
    }
    i = i + 1;
    <D.19806>:
    if (i < end) goto <D.19805>; else goto <D.19807>;
    <D.19807>:
  }
  goto <D.22250>;
  <D.22236>:
  {
    int middle;
    struct MonoIMTCheckItem * item;

    D.22251 = count / 2;
    middle = D.22251 + start;
    item = monoeg_malloc0 (48);
    D.22252 = (long unsigned int) middle;
    D.22253 = D.22252 * 8;
    D.22254 = sorted_array + D.22253;
    D.22255 = *D.22254;
    D.22256 = D.22255->key;
    item->key = D.22256;
    item->is_equals = 0;
    monoeg_g_ptr_array_add (out_array, item);
    imt_emit_ir (sorted_array, start, middle, out_array);
    D.22257 = imt_emit_ir (sorted_array, middle, end, out_array);
    item->check_target_idx = D.22257;
  }
  <D.22250>:
  D.22258 = chunk_start;
  return D.22258;
}


mono_method_alloc_generic_virtual_thunk (struct MonoDomain * domain, int size)
{
  unsigned int size.44;
  unsigned int D.22261;
  unsigned int size.45;
  struct MonoThunkFreeList * * D.22265;
  long unsigned int D.22266;
  long unsigned int D.22267;
  struct MonoThunkFreeList * D.22268;
  unsigned int D.22269;
  unsigned int size.46;
  struct _MonoThunkFreeList * D.22273;
  void * D.22274;
  struct MonoThunkFreeList * * D.22275;
  unsigned int D.22278;
  _Bool D.22279;
  long int D.22280;
  long int D.22281;
  struct _MonoThunkFreeList * D.22284;
  int inited.47;
  int generic_virtual_thunks_size.48;
  int generic_virtual_thunks_size.49;
  union mono_mutex_t * D.22290;
  _Bool D.22293;
  long int D.22294;
  long int D.22295;
  struct GHashTable * D.22298;
  struct GHashTable * D.22301;
  _Bool D.22304;
  long int D.22305;
  long int D.22306;
  static gboolean inited = 0;
  static int generic_virtual_thunks_size = 0;
  guint32 * p;
  int i;
  struct MonoThunkFreeList * * l;

  init_thunk_free_lists (domain);
  size.44 = (unsigned int) size;
  D.22261 = size.44 + 4;
  size = (int) D.22261;
  size.45 = (unsigned int) size;
  if (size.45 <= 15) goto <D.22263>; else goto <D.22264>;
  <D.22263>:
  size = 16;
  <D.22264>:
  i = list_index_for_size (size);
  D.22265 = domain->thunk_free_lists;
  D.22266 = (long unsigned int) i;
  D.22267 = D.22266 * 8;
  l = D.22265 + D.22267;
  goto <D.19927>;
  <D.19926>:
  D.22268 = *l;
  D.22269 = D.22268->size;
  size.46 = (unsigned int) size;
  if (D.22269 >= size.46) goto <D.22271>; else goto <D.22272>;
  <D.22271>:
  {
    struct MonoThunkFreeList * item;

    item = *l;
    D.22273 = item->next;
    *l = D.22273;
    D.22274 = item + 4;
    return D.22274;
  }
  <D.22272>:
  D.22268 = *l;
  l = &D.22268->next;
  <D.19927>:
  D.22268 = *l;
  if (D.22268 != 0B) goto <D.19926>; else goto <D.19928>;
  <D.19928>:
  goto <D.19930>;
  <D.19931>:
  {
    struct MonoThunkFreeList * item;

    D.22265 = domain->thunk_free_lists;
    D.22266 = (long unsigned int) i;
    D.22267 = D.22266 * 8;
    D.22275 = D.22265 + D.22267;
    item = *D.22275;
    if (item == 0B) goto <D.22276>; else goto <D.22277>;
    <D.22276>:
    // predicted unlikely by continue predictor.
    goto <D.19930>;
    <D.22277>:
    D.22278 = item->size;
    size.46 = (unsigned int) size;
    D.22279 = D.22278 <= size.46;
    D.22280 = (long int) D.22279;
    D.22281 = __builtin_expect (D.22280, 0);
    if (D.22281 != 0) goto <D.22282>; else goto <D.22283>;
    <D.22282>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 1550, "item->size > size");
    <D.22283>:
    D.22265 = domain->thunk_free_lists;
    D.22266 = (long unsigned int) i;
    D.22267 = D.22266 * 8;
    D.22275 = D.22265 + D.22267;
    D.22284 = item->next;
    *D.22275 = D.22284;
    D.22274 = item + 4;
    return D.22274;
  }
  <D.19930>:
  i = i + 1;
  if (i <= 11) goto <D.19931>; else goto <D.19932>;
  <D.19932>:
  inited.47 = inited;
  if (inited.47 == 0) goto <D.22286>; else goto <D.22287>;
  <D.22286>:
  mono_counters_register ("Generic virtual thunk bytes", 2048, &generic_virtual_thunks_size);
  inited = 1;
  <D.22287>:
  generic_virtual_thunks_size.48 = generic_virtual_thunks_size;
  generic_virtual_thunks_size.49 = generic_virtual_thunks_size.48 + size;
  generic_virtual_thunks_size = generic_virtual_thunks_size.49;
  p = mono_domain_code_reserve (domain, size);
  size.46 = (unsigned int) size;
  *p = size.46;
  {
    int ret;

    D.22290 = &domain->lock.mutex;
    ret = pthread_mutex_lock (D.22290);
    if (ret != 0) goto <D.22291>; else goto <D.22292>;
    <D.22291>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
    <D.22292>:
    D.22293 = ret != 0;
    D.22294 = (long int) D.22293;
    D.22295 = __builtin_expect (D.22294, 0);
    if (D.22295 != 0) goto <D.22296>; else goto <D.22297>;
    <D.22296>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 1566, "ret == 0");
    <D.22297>:
  }
  D.22298 = domain->generic_virtual_thunks;
  if (D.22298 == 0B) goto <D.22299>; else goto <D.22300>;
  <D.22299>:
  D.22301 = monoeg_g_hash_table_new (0B, 0B);
  domain->generic_virtual_thunks = D.22301;
  <D.22300>:
  D.22298 = domain->generic_virtual_thunks;
  monoeg_g_hash_table_insert_replace (D.22298, p, p, 0);
  {
    int ret;

    D.22290 = &domain->lock.mutex;
    ret = pthread_mutex_unlock (D.22290);
    if (ret != 0) goto <D.22302>; else goto <D.22303>;
    <D.22302>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.22303>:
    D.22304 = ret != 0;
    D.22305 = (long int) D.22304;
    D.22306 = __builtin_expect (D.22305, 0);
    if (D.22306 != 0) goto <D.22307>; else goto <D.22308>;
    <D.22307>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 1570, "ret == 0");
    <D.22308>:
  }
  D.22274 = p + 4;
  return D.22274;
}


init_thunk_free_lists (struct MonoDomain * domain)
{
  struct MonoThunkFreeList * * D.22310;
  void * D.22313;

  D.22310 = domain->thunk_free_lists;
  if (D.22310 != 0B) goto <D.22311>; else goto <D.22312>;
  <D.22311>:
  return;
  <D.22312>:
  D.22313 = mono_domain_alloc0 (domain, 96);
  domain->thunk_free_lists = D.22313;
}


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

  i = 2;
  size = 64;
  goto <D.19914>;
  <D.19913>:
  i = i + 1;
  size = size << 1;
  <D.19914>:
  if (item_size > size) goto <D.22315>; else goto <D.19915>;
  <D.22315>:
  if (i <= 10) goto <D.19913>; else goto <D.19915>;
  <D.19915>:
  D.22316 = i;
  return D.22316;
}


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.22318;
  _Bool D.22321;
  long int D.22322;
  long int D.22323;
  struct GHashTable * D.22326;
  struct GHashTable * D.22329;
  struct MonoMethod * D.22330;
  void * D.22334;
  int inited.50;
  int num_added.51;
  int num_added.52;
  int D.22340;
  int D.22341;
  long int vtable_slot.53;
  long int vtable.54;
  long int D.22348;
  long int D.22349;
  void * (*<T25d8>) (int) D.22350;
  void * iftmp.55;
  void * (*<T25d8>) (int) D.22353;
  void *[0:] * D.22356;
  long int D.22357;
  long int D.22358;
  long int D.22359;
  int D.22360;
  void * (*<T2810>) (struct MonoVTable *, struct MonoDomain *, struct MonoIMTCheckItem * *, int, void *) imt_thunk_builder.56;
  void * * D.22363;
  unsigned int D.22364;
  int D.22365;
  void * D.22366;
  long unsigned int D.22367;
  long unsigned int D.22368;
  void * * D.22369;
  void * D.22370;
  unsigned int i.57;
  _Bool D.22378;
  long int D.22379;
  long int D.22380;
  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.22318 = &domain->lock.mutex;
    ret = pthread_mutex_lock (D.22318);
    if (ret != 0) goto <D.22319>; else goto <D.22320>;
    <D.22319>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
    <D.22320>:
    D.22321 = ret != 0;
    D.22322 = (long int) D.22321;
    D.22323 = __builtin_expect (D.22322, 0);
    if (D.22323 != 0) goto <D.22324>; else goto <D.22325>;
    <D.22324>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 1699, "ret == 0");
    <D.22325>:
  }
  D.22326 = domain->generic_virtual_cases;
  if (D.22326 == 0B) goto <D.22327>; else goto <D.22328>;
  <D.22327>:
  D.22329 = monoeg_g_hash_table_new (mono_aligned_addr_hash, 0B);
  domain->generic_virtual_cases = D.22329;
  <D.22328>:
  D.22326 = domain->generic_virtual_cases;
  list = monoeg_g_hash_table_lookup (D.22326, vtable_slot);
  gvc = list;
  goto <D.19986>;
  <D.19985>:
  D.22330 = gvc->method;
  if (D.22330 == method) goto <D.19984>; else goto <D.22331>;
  <D.22331>:
  gvc = gvc->next;
  <D.19986>:
  if (gvc != 0B) goto <D.19985>; else goto <D.19984>;
  <D.19984>:
  if (gvc == 0B) goto <D.22332>; else goto <D.22333>;
  <D.22332>:
  gvc = mono_domain_alloc (domain, 32);
  gvc->method = method;
  gvc->code = code;
  gvc->count = 0;
  D.22326 = domain->generic_virtual_cases;
  D.22334 = monoeg_g_hash_table_lookup (D.22326, vtable_slot);
  gvc->next = D.22334;
  D.22326 = domain->generic_virtual_cases;
  monoeg_g_hash_table_insert_replace (D.22326, vtable_slot, gvc, 0);
  inited.50 = inited;
  if (inited.50 == 0) goto <D.22336>; else goto <D.22337>;
  <D.22336>:
  mono_counters_register ("Generic virtual cases", 2048, &num_added);
  inited = 1;
  <D.22337>:
  num_added.51 = num_added;
  num_added.52 = num_added.51 + 1;
  num_added = num_added.52;
  <D.22333>:
  D.22340 = gvc->count;
  D.22341 = D.22340 + 1;
  gvc->count = D.22341;
  D.22340 = gvc->count;
  if (D.22340 == 10) goto <D.22342>; else goto <D.22343>;
  <D.22342>:
  {
    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.22344>; else goto <D.22345>;
    <D.22344>:
    {
      int displacement;
      int imt_slot;

      vtable_slot.53 = (long int) vtable_slot;
      vtable.54 = (long int) vtable;
      D.22348 = vtable_slot.53 - vtable.54;
      D.22349 = D.22348 /[ex] 8;
      displacement = (int) D.22349;
      imt_slot = displacement + 19;
      D.22350 = callbacks.get_imt_trampoline;
      imt_trampoline = D.22350 (imt_slot);
      *vtable_slot = imt_trampoline;
    }
    goto <D.22351>;
    <D.22345>:
    D.22353 = callbacks.get_vtable_trampoline;
    if (D.22353 != 0B) goto <D.22354>; else goto <D.22355>;
    <D.22354>:
    D.22353 = callbacks.get_vtable_trampoline;
    vtable_slot.53 = (long int) vtable_slot;
    D.22356 = &vtable->vtable;
    D.22357 = (long int) D.22356;
    D.22358 = vtable_slot.53 - D.22357;
    D.22359 = D.22358 /[ex] 8;
    D.22360 = (int) D.22359;
    iftmp.55 = D.22353 (D.22360);
    goto <D.22361>;
    <D.22355>:
    iftmp.55 = 0B;
    <D.22361>:
    vtable_trampoline = iftmp.55;
    entries = get_generic_virtual_entries (domain, vtable_slot);
    sorted = imt_sort_slot_entries (entries);
    imt_thunk_builder.56 = imt_thunk_builder;
    D.22363 = sorted->pdata;
    D.22364 = sorted->len;
    D.22365 = (int) D.22364;
    D.22366 = imt_thunk_builder.56 (0B, domain, D.22363, D.22365, vtable_trampoline);
    *vtable_slot = D.22366;
    goto <D.19994>;
    <D.19993>:
    {
      struct MonoImtBuilderEntry * next;

      next = entries->next;
      monoeg_g_free (entries);
      entries = next;
    }
    <D.19994>:
    if (entries != 0B) goto <D.19993>; else goto <D.19995>;
    <D.19995>:
    i = 0;
    goto <D.19997>;
    <D.19996>:
    D.22363 = sorted->pdata;
    D.22367 = (long unsigned int) i;
    D.22368 = D.22367 * 8;
    D.22369 = D.22363 + D.22368;
    D.22370 = *D.22369;
    monoeg_g_free (D.22370);
    i = i + 1;
    <D.19997>:
    i.57 = (unsigned int) i;
    D.22364 = sorted->len;
    if (i.57 < D.22364) goto <D.19996>; else goto <D.19998>;
    <D.19998>:
    monoeg_g_ptr_array_free (sorted, 1);
    <D.22351>:
    if (old_thunk != vtable_trampoline) goto <D.22372>; else goto <D.22373>;
    <D.22372>:
    if (old_thunk != imt_trampoline) goto <D.22374>; else goto <D.22375>;
    <D.22374>:
    invalidate_generic_virtual_thunk (domain, old_thunk);
    <D.22375>:
    <D.22373>:
  }
  <D.22343>:
  {
    int ret;

    D.22318 = &domain->lock.mutex;
    ret = pthread_mutex_unlock (D.22318);
    if (ret != 0) goto <D.22376>; else goto <D.22377>;
    <D.22376>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.22377>:
    D.22378 = ret != 0;
    D.22379 = (long int) D.22378;
    D.22380 = __builtin_expect (D.22379, 0);
    if (D.22380 != 0) goto <D.22381>; else goto <D.22382>;
    <D.22381>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 1770, "ret == 0");
    <D.22382>:
  }
}


invalidate_generic_virtual_thunk (struct MonoDomain * domain, void * code)
{
  union mono_mutex_t * D.22383;
  _Bool D.22386;
  long int D.22387;
  long int D.22388;
  struct GHashTable * D.22391;
  struct GHashTable * D.22394;
  void * D.22395;
  _Bool D.22400;
  long int D.22401;
  long int D.22402;
  struct MonoThunkFreeList * * D.22407;
  struct _MonoThunkFreeList * D.22408;
  struct MonoThunkFreeList * D.22409;
  int D.22410;
  unsigned int D.22411;
  int D.22412;
  long unsigned int D.22413;
  long unsigned int D.22414;
  struct MonoThunkFreeList * * D.22415;
  struct MonoThunkFreeList * D.22416;
  int D.22418;
  struct MonoThunkFreeList * * D.22419;
  struct MonoThunkFreeList * D.22420;
  struct _MonoThunkFreeList * D.22423;
  int D.22424;
  _Bool D.22426;
  long int D.22427;
  long int D.22428;
  guint32 * p;
  struct MonoThunkFreeList * l;
  gboolean found;

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

    D.22383 = &domain->lock.mutex;
    ret = pthread_mutex_lock (D.22383);
    if (ret != 0) goto <D.22384>; else goto <D.22385>;
    <D.22384>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
    <D.22385>:
    D.22386 = ret != 0;
    D.22387 = (long int) D.22386;
    D.22388 = __builtin_expect (D.22387, 0);
    if (D.22388 != 0) goto <D.22389>; else goto <D.22390>;
    <D.22389>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 1585, "ret == 0");
    <D.22390>:
  }
  D.22391 = domain->generic_virtual_thunks;
  if (D.22391 == 0B) goto <D.22392>; else goto <D.22393>;
  <D.22392>:
  D.22394 = monoeg_g_hash_table_new (0B, 0B);
  domain->generic_virtual_thunks = D.22394;
  <D.22393>:
  D.22391 = domain->generic_virtual_thunks;
  D.22395 = monoeg_g_hash_table_lookup (D.22391, l);
  if (D.22395 != 0B) goto <D.22396>; else goto <D.22397>;
  <D.22396>:
  found = 1;
  <D.22397>:
  {
    int ret;

    D.22383 = &domain->lock.mutex;
    ret = pthread_mutex_unlock (D.22383);
    if (ret != 0) goto <D.22398>; else goto <D.22399>;
    <D.22398>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.22399>:
    D.22400 = ret != 0;
    D.22401 = (long int) D.22400;
    D.22402 = __builtin_expect (D.22401, 0);
    if (D.22402 != 0) goto <D.22403>; else goto <D.22404>;
    <D.22403>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 1590, "ret == 0");
    <D.22404>:
  }
  if (found == 0) goto <D.22405>; else goto <D.22406>;
  <D.22405>:
  return;
  <D.22406>:
  init_thunk_free_lists (domain);
  goto <D.19948>;
  <D.19947>:
  {
    struct MonoThunkFreeList * item;
    int length;
    int i;

    D.22407 = domain->thunk_free_lists;
    item = *D.22407;
    length = item->length;
    D.22407 = domain->thunk_free_lists;
    D.22408 = item->next;
    *D.22407 = D.22408;
    D.22407 = domain->thunk_free_lists;
    D.22409 = *D.22407;
    D.22410 = length + -1;
    D.22409->length = D.22410;
    D.22411 = item->size;
    D.22412 = (int) D.22411;
    i = list_index_for_size (D.22412);
    D.22407 = domain->thunk_free_lists;
    D.22413 = (long unsigned int) i;
    D.22414 = D.22413 * 8;
    D.22415 = D.22407 + D.22414;
    D.22416 = *D.22415;
    item->next = D.22416;
    D.22407 = domain->thunk_free_lists;
    D.22413 = (long unsigned int) i;
    D.22414 = D.22413 * 8;
    D.22415 = D.22407 + D.22414;
    *D.22415 = item;
  }
  <D.19948>:
  D.22407 = domain->thunk_free_lists;
  D.22409 = *D.22407;
  if (D.22409 != 0B) goto <D.22417>; else goto <D.19949>;
  <D.22417>:
  D.22407 = domain->thunk_free_lists;
  D.22409 = *D.22407;
  D.22418 = D.22409->length;
  if (D.22418 > 49) goto <D.19947>; else goto <D.19949>;
  <D.19949>:
  l->next = 0B;
  D.22407 = domain->thunk_free_lists;
  D.22419 = D.22407 + 8;
  D.22420 = *D.22419;
  if (D.22420 != 0B) goto <D.22421>; else goto <D.22422>;
  <D.22421>:
  D.22407 = domain->thunk_free_lists;
  D.22419 = D.22407 + 8;
  D.22407 = domain->thunk_free_lists;
  D.22419 = D.22407 + 8;
  D.22420 = *D.22419;
  D.22420->next = l;
  D.22423 = D.22420->next;
  *D.22419 = D.22423;
  D.22407 = domain->thunk_free_lists;
  D.22409 = *D.22407;
  D.22418 = D.22409->length;
  D.22424 = D.22418 + 1;
  D.22409->length = D.22424;
  goto <D.22425>;
  <D.22422>:
  D.22407 = domain->thunk_free_lists;
  D.22409 = *D.22407;
  D.22426 = D.22409 != 0B;
  D.22427 = (long int) D.22426;
  D.22428 = __builtin_expect (D.22427, 0);
  if (D.22428 != 0) goto <D.22429>; else goto <D.22430>;
  <D.22429>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 1618, "!domain->thunk_free_lists [0]");
  <D.22430>:
  D.22407 = domain->thunk_free_lists;
  D.22407 = domain->thunk_free_lists;
  D.22419 = D.22407 + 8;
  *D.22419 = l;
  D.22420 = *D.22419;
  *D.22407 = D.22420;
  D.22407 = domain->thunk_free_lists;
  D.22409 = *D.22407;
  D.22409->length = 1;
  <D.22425>:
}


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

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


mono_class_vtable_full (struct MonoDomain * domain, struct MonoClass * class, gboolean raise_on_error)
{
  _Bool D.22434;
  long int D.22435;
  long int D.22436;
  unsigned char D.22439;
  struct MonoException * D.22444;
  struct MonoVTable * D.22445;
  short unsigned int D.22448;
  int D.22449;
  int D.22450;
  struct MonoVTable * D.22453;
  struct MonoClassRuntimeInfo * runtime_info;

  D.22434 = class == 0B;
  D.22435 = (long int) D.22434;
  D.22436 = __builtin_expect (D.22435, 0);
  if (D.22436 != 0) goto <D.22437>; else goto <D.22438>;
  <D.22437>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 1804, "class");
  <D.22438>:
  D.22439 = class->exception_type;
  if (D.22439 != 0) goto <D.22440>; else goto <D.22441>;
  <D.22440>:
  if (raise_on_error != 0) goto <D.22442>; else goto <D.22443>;
  <D.22442>:
  D.22444 = mono_class_get_exception_for_failure (class);
  mono_raise_exception (D.22444);
  <D.22443>:
  D.22445 = 0B;
  return D.22445;
  <D.22441>:
  runtime_info = class->runtime_info;
  if (runtime_info != 0B) goto <D.22446>; else goto <D.22447>;
  <D.22446>:
  D.22448 = runtime_info->max_domain;
  D.22449 = (int) D.22448;
  D.22450 = domain->domain_id;
  if (D.22449 >= D.22450) goto <D.22451>; else goto <D.22452>;
  <D.22451>:
  D.22450 = domain->domain_id;
  D.22453 = runtime_info->domain_vtables[D.22450];
  if (D.22453 != 0B) goto <D.22454>; else goto <D.22455>;
  <D.22454>:
  D.22450 = domain->domain_id;
  D.22445 = runtime_info->domain_vtables[D.22450];
  return D.22445;
  <D.22455>:
  <D.22452>:
  <D.22447>:
  D.22445 = mono_class_create_runtime_vtable (domain, class, raise_on_error);
  return D.22445;
}


mono_class_create_runtime_vtable (struct MonoDomain * domain, struct MonoClass * class, gboolean raise_on_error)
{
  union mono_mutex_t * D.22457;
  _Bool D.22460;
  long int D.22461;
  long int D.22462;
  short unsigned int D.22467;
  int D.22468;
  int D.22469;
  struct MonoVTable * D.22472;
  _Bool D.22477;
  long int D.22478;
  long int D.22479;
  struct MonoVTable * D.22482;
  long unsigned int D.22483;
  long unsigned int D.22484;
  int D.22489;
  unsigned char D.22491;
  _Bool D.22494;
  long int D.22495;
  long int D.22496;
  struct MonoException * D.22501;
  unsigned char D.22504;
  long unsigned int D.22506;
  long unsigned int D.22507;
  unsigned char D.22510;
  int D.22513;
  _Bool D.22522;
  long int D.22523;
  long int D.22524;
  struct MonoException * D.22529;
  int D.22530;
  struct MonoGenericClass * D.22533;
  struct MonoMethod * * D.22536;
  _Bool D.22543;
  long int D.22544;
  long int D.22545;
  struct MonoException * D.22550;
  int D.22551;
  void * (*<T2810>) (struct MonoVTable *, struct MonoDomain *, struct MonoIMTCheckItem * *, int, void *) imt_thunk_builder.58;
  long unsigned int D.22557;
  long unsigned int D.22558;
  unsigned int D.22559;
  short unsigned int D.22560;
  long unsigned int D.22563;
  long unsigned int D.22564;
  long unsigned int D.22565;
  long unsigned int D.22566;
  short unsigned int D.22568;
  int D.22569;
  int D.22570;
  long unsigned int D.22571;
  long unsigned int D.22572;
  long unsigned int D.22573;
  unsigned int D.22574;
  long unsigned int D.22575;
  long unsigned int D.22576;
  long unsigned int D.22577;
  long unsigned int D.22578;
  long unsigned int D.22579;
  sizetype D.22582;
  sizetype D.22584;
  sizetype D.22585;
  sizetype D.22586;
  unsigned char D.22587;
  void * D.22588;
  unsigned int D.22589;
  int D.22590;
  _Bool D.22591;
  long int D.22592;
  long int D.22593;
  unsigned char D.22596;
  <unnamed-unsigned:4> D.22597;
  long unsigned int D.22600;
  int max_set.59;
  int D.22604;
  long unsigned int D.22605;
  void * D.22606;
  void * D.22607;
  void * D.22611;
  long unsigned int D.22612;
  long unsigned int D.22613;
  long unsigned int D.22614;
  struct MonoType * D.22615;
  short unsigned int D.22616;
  int D.22617;
  int D.22618;
  int D.22621;
  int D.20057;
  int iftmp.60;
  int D.20056;
  const char[9] * D.22627;
  unsigned char D.22628;
  int D.22629;
  unsigned char D.22630;
  int D.22631;
  const unsigned char * D.22636;
  unsigned char D.22637;
  int D.22638;
  const unsigned char * D.22639;
  unsigned char D.22640;
  int D.22641;
  const unsigned char * D.22646;
  unsigned char D.22647;
  int D.22648;
  const unsigned char * D.22649;
  unsigned char D.22650;
  int D.22651;
  const unsigned char * D.22656;
  unsigned char D.22657;
  int D.22658;
  const unsigned char * D.22659;
  unsigned char D.22660;
  int D.22661;
  const char * D.22663;
  int D.22666;
  int iftmp.61;
  long unsigned int D.22670;
  int D.22676;
  int D.22680;
  int max_set.62;
  int D.22685;
  unsigned int special_static.63;
  int align.64;
  unsigned int align.65;
  struct GHashTable * D.22689;
  struct GHashTable * D.22692;
  long unsigned int D.22693;
  void * D.22694;
  int D.22697;
  signed short D.22700;
  _Bool D.22701;
  long int D.22702;
  long int D.22703;
  void * D.22706;
  int D.22707;
  sizetype D.22708;
  long unsigned int D.22711;
  long unsigned int D.22712;
  int D.22715;
  long unsigned int D.22716;
  int iftmp.66;
  unsigned char D.22721;
  _Bool D.22724;
  long int D.22725;
  long int D.22726;
  char D.22729;
  guint8 * D.22730;
  struct MonoClass * * D.22733;
  long unsigned int D.22734;
  long unsigned int D.22735;
  struct MonoClass * * D.22736;
  struct MonoClass * D.22737;
  short unsigned int D.22738;
  guint16 * D.22739;
  long unsigned int D.22740;
  guint16 * D.22741;
  short unsigned int D.22742;
  int D.22743;
  long unsigned int D.22744;
  long unsigned int D.22745;
  void * * D.22746;
  void * * D.22747;
  int D.22748;
  void * (*<T25d8>) (int) D.22749;
  void * D.22752;
  struct MonoMethod * * D.22754;
  void * (*<T1e52>) (struct MonoMethod *) arch_create_jit_trampoline.67;
  void * D.22758;
  void * (*<T25d8>) (int) D.22763;
  void * * D.22766;
  void * D.22767;
  struct MonoClass * D.22769;
  struct MonoType * D.22772;
  struct MonoReflectionType * D.22773;
  void * D.22774;
  struct MonoClass * D.22775;
  int D.22778;
  void * * D.22783;
  void * D.22784;
  long unsigned int D.22785;
  _Bool D.22786;
  struct GPtrArray * D.22787;
  short unsigned int D.22791;
  int D.22792;
  int D.22796;
  struct MonoImage * D.22797;
  long unsigned int D.22798;
  long unsigned int D.22799;
  unsigned int D.22800;
  unsigned int D.22801;
  short unsigned int D.22802;
  short unsigned int D.22803;
  struct MonoVTable *[0:] * D.22806;
  struct MonoVTable *[0:] * D.22807;
  int D.22808;
  long unsigned int D.22809;
  long unsigned int D.22810;
  struct MonoReflectionType * D.22813;
  struct MonoClass * D.22814;
  int D.22817;
  void * D.22822;
  _Bool D.22825;
  long int D.22826;
  long int D.22827;
  int D.22830;
  struct MonoException * D.22837;
  struct MonoClass * D.22838;
  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.22457 = &domain->lock.mutex;
        ret = pthread_mutex_lock (D.22457);
        if (ret != 0) goto <D.22458>; else goto <D.22459>;
        <D.22458>:
        monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
        <D.22459>:
        D.22460 = ret != 0;
        D.22461 = (long int) D.22460;
        D.22462 = __builtin_expect (D.22461, 0);
        if (D.22462 != 0) goto <D.22463>; else goto <D.22464>;
        <D.22463>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 1856, "ret == 0");
        <D.22464>:
      }
      runtime_info = class->runtime_info;
      if (runtime_info != 0B) goto <D.22465>; else goto <D.22466>;
      <D.22465>:
      D.22467 = runtime_info->max_domain;
      D.22468 = (int) D.22467;
      D.22469 = domain->domain_id;
      if (D.22468 >= D.22469) goto <D.22470>; else goto <D.22471>;
      <D.22470>:
      D.22469 = domain->domain_id;
      D.22472 = runtime_info->domain_vtables[D.22469];
      if (D.22472 != 0B) goto <D.22473>; else goto <D.22474>;
      <D.22473>:
      {
        int ret;

        D.22457 = &domain->lock.mutex;
        ret = pthread_mutex_unlock (D.22457);
        if (ret != 0) goto <D.22475>; else goto <D.22476>;
        <D.22475>:
        monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
        <D.22476>:
        D.22477 = ret != 0;
        D.22478 = (long int) D.22477;
        D.22479 = __builtin_expect (D.22478, 0);
        if (D.22479 != 0) goto <D.22480>; else goto <D.22481>;
        <D.22480>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 1859, "ret == 0");
        <D.22481>:
      }
      mono_loader_unlock ();
      D.22469 = domain->domain_id;
      D.22482 = runtime_info->domain_vtables[D.22469];
      return D.22482;
      <D.22474>:
      <D.22471>:
      <D.22466>:
      D.22483 = BIT_FIELD_REF <*class, 64, 256>;
      D.22484 = D.22483 & 280375465082881;
      if (D.22484 != 1) goto <D.22485>; else goto <D.22486>;
      <D.22485>:
      D.22489 = mono_class_init (class);
      if (D.22489 == 0) goto <D.22487>; else goto <D.22490>;
      <D.22490>:
      D.22491 = class->exception_type;
      if (D.22491 != 0) goto <D.22487>; else goto <D.22488>;
      <D.22487>:
      {
        int ret;

        D.22457 = &domain->lock.mutex;
        ret = pthread_mutex_unlock (D.22457);
        if (ret != 0) goto <D.22492>; else goto <D.22493>;
        <D.22492>:
        monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
        <D.22493>:
        D.22494 = ret != 0;
        D.22495 = (long int) D.22494;
        D.22496 = __builtin_expect (D.22495, 0);
        if (D.22496 != 0) goto <D.22497>; else goto <D.22498>;
        <D.22497>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 1865, "ret == 0");
        <D.22498>:
      }
      mono_loader_unlock ();
      if (raise_on_error != 0) goto <D.22499>; else goto <D.22500>;
      <D.22499>:
      D.22501 = mono_class_get_exception_for_failure (class);
      mono_raise_exception (D.22501);
      <D.22500>:
      D.22482 = 0B;
      return D.22482;
      <D.22488>:
      <D.22486>:
      D.22504 = class->byval_arg.type;
      if (D.22504 == 20) goto <D.22502>; else goto <D.22505>;
      <D.22505>:
      D.22504 = class->byval_arg.type;
      if (D.22504 == 29) goto <D.22502>; else goto <D.22503>;
      <D.22502>:
      {
        struct MonoClass * element_class;

        element_class = class->element_class;
        D.22506 = BIT_FIELD_REF <*element_class, 64, 256>;
        D.22507 = D.22506 & 1;
        if (D.22507 == 0) goto <D.22508>; else goto <D.22509>;
        <D.22508>:
        mono_class_init (element_class);
        <D.22509>:
        D.22510 = element_class->exception_type;
        if (D.22510 == 0) goto <D.22511>; else goto <D.22512>;
        <D.22511>:
        D.22513 = element_class->vtable_size;
        if (D.22513 == 0) goto <D.22514>; else goto <D.22515>;
        <D.22514>:
        mono_class_setup_vtable (element_class);
        <D.22515>:
        <D.22512>:
        D.22510 = element_class->exception_type;
        if (D.22510 != 0) goto <D.22516>; else goto <D.22517>;
        <D.22516>:
        D.22491 = class->exception_type;
        if (D.22491 == 0) goto <D.22518>; else goto <D.22519>;
        <D.22518>:
        mono_class_set_failure (class, 7, 0B);
        <D.22519>:
        {
          int ret;

          D.22457 = &domain->lock.mutex;
          ret = pthread_mutex_unlock (D.22457);
          if (ret != 0) goto <D.22520>; else goto <D.22521>;
          <D.22520>:
          monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
          <D.22521>:
          D.22522 = ret != 0;
          D.22523 = (long int) D.22522;
          D.22524 = __builtin_expect (D.22523, 0);
          if (D.22524 != 0) goto <D.22525>; else goto <D.22526>;
          <D.22525>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 1887, "ret == 0");
          <D.22526>:
        }
        mono_loader_unlock ();
        if (raise_on_error != 0) goto <D.22527>; else goto <D.22528>;
        <D.22527>:
        D.22529 = mono_class_get_exception_for_failure (class);
        mono_raise_exception (D.22529);
        <D.22528>:
        D.22482 = 0B;
        return D.22482;
        <D.22517>:
      }
      <D.22503>:
      D.22530 = class->vtable_size;
      if (D.22530 == 0) goto <D.22531>; else goto <D.22532>;
      <D.22531>:
      mono_class_setup_vtable (class);
      <D.22532>:
      D.22533 = class->generic_class;
      if (D.22533 != 0B) goto <D.22534>; else goto <D.22535>;
      <D.22534>:
      D.22536 = class->vtable;
      if (D.22536 == 0B) goto <D.22537>; else goto <D.22538>;
      <D.22537>:
      mono_class_check_vtable_constraints (class, 0B);
      <D.22538>:
      <D.22535>:
      mono_class_has_finalizer (class);
      D.22491 = class->exception_type;
      if (D.22491 != 0) goto <D.22539>; else goto <D.22540>;
      <D.22539>:
      {
        int ret;

        D.22457 = &domain->lock.mutex;
        ret = pthread_mutex_unlock (D.22457);
        if (ret != 0) goto <D.22541>; else goto <D.22542>;
        <D.22541>:
        monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
        <D.22542>:
        D.22543 = ret != 0;
        D.22544 = (long int) D.22543;
        D.22545 = __builtin_expect (D.22544, 0);
        if (D.22545 != 0) goto <D.22546>; else goto <D.22547>;
        <D.22546>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 1909, "ret == 0");
        <D.22547>:
      }
      mono_loader_unlock ();
      if (raise_on_error != 0) goto <D.22548>; else goto <D.22549>;
      <D.22548>:
      D.22550 = mono_class_get_exception_for_failure (class);
      mono_raise_exception (D.22550);
      <D.22549>:
      D.22482 = 0B;
      return D.22482;
      <D.22540>:
      vtable_slots = class->vtable_size;
      D.22551 = mono_class_data_size (class);
      class_size = (guint32) D.22551;
      if (class_size != 0) goto <D.22552>; else goto <D.22553>;
      <D.22552>:
      vtable_slots = vtable_slots + 1;
      <D.22553>:
      imt_thunk_builder.58 = imt_thunk_builder;
      if (imt_thunk_builder.58 != 0B) goto <D.22555>; else goto <D.22556>;
      <D.22555>:
      D.22557 = (long unsigned int) vtable_slots;
      D.22558 = D.22557 + 7;
      D.22559 = (unsigned int) D.22558;
      vtable_size = D.22559 * 8;
      D.22560 = class->interface_offsets_count;
      if (D.22560 != 0) goto <D.22561>; else goto <D.22562>;
      <D.22561>:
      imt_table_bytes = 152;
      vtable_size = vtable_size + 152;
      D.22563 = mono_stats.imt_number_of_tables;
      D.22564 = D.22563 + 1;
      mono_stats.imt_number_of_tables = D.22564;
      D.22565 = mono_stats.imt_tables_size;
      D.22566 = D.22565 + 152;
      mono_stats.imt_tables_size = D.22566;
      <D.22562>:
      goto <D.22567>;
      <D.22556>:
      D.22568 = class->max_interface_id;
      D.22569 = (int) D.22568;
      D.22570 = D.22569 + 1;
      D.22571 = (long unsigned int) D.22570;
      D.22557 = (long unsigned int) vtable_slots;
      D.22572 = D.22571 + D.22557;
      D.22573 = D.22572 + 7;
      D.22574 = (unsigned int) D.22573;
      vtable_size = D.22574 * 8;
      <D.22567>:
      D.22575 = mono_stats.used_class_count;
      D.22576 = D.22575 + 1;
      mono_stats.used_class_count = D.22576;
      D.22577 = mono_stats.class_vtable_size;
      D.22578 = (long unsigned int) vtable_size;
      D.22579 = D.22577 + D.22578;
      mono_stats.class_vtable_size = D.22579;
      interface_offsets = mono_domain_alloc0 (domain, vtable_size);
      imt_thunk_builder.58 = imt_thunk_builder;
      if (imt_thunk_builder.58 != 0B) goto <D.22580>; else goto <D.22581>;
      <D.22580>:
      D.22582 = (sizetype) imt_table_bytes;
      vt = interface_offsets + D.22582;
      goto <D.22583>;
      <D.22581>:
      D.22568 = class->max_interface_id;
      D.22584 = (sizetype) D.22568;
      D.22585 = D.22584 + 1;
      D.22586 = D.22585 * 8;
      vt = interface_offsets + D.22586;
      <D.22583>:
      vt->klass = class;
      D.22587 = class->rank;
      vt->rank = D.22587;
      vt->domain = domain;
      mono_class_compute_gc_descriptor (class);
      D.22588 = class->gc_descr;
      vt->gc_descr = D.22588;
      D.22589 = mono_gc_get_vtable_bits (class);
      gc_bits = (int) D.22589;
      D.22590 = gc_bits & -16;
      D.22591 = D.22590 != 0;
      D.22592 = (long int) D.22591;
      D.22593 = __builtin_expect (D.22592, 0);
      if (D.22593 != 0) goto <D.22594>; else goto <D.22595>;
      <D.22594>:
      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.22595>:
      D.22596 = (unsigned char) gc_bits;
      D.22597 = (<unnamed-unsigned:4>) D.22596;
      vt->gc_bits = D.22597;
      if (class_size != 0) goto <D.22598>; else goto <D.22599>;
      <D.22598>:
      D.22483 = BIT_FIELD_REF <*class, 64, 256>;
      D.22600 = D.22483 & 268435456;
      if (D.22600 != 0) goto <D.22601>; else goto <D.22602>;
      <D.22601>:
      {
        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, 256, 0, &max_set, 1);
            max_set.59 = max_set;
            D.22604 = max_set.59 + 1;
            statics_gc_descr = mono_gc_make_descr_from_bitmap (bitmap, D.22604);
            D.22530 = class->vtable_size;
            D.22605 = (long unsigned int) class_size;
            D.22606 = mono_gc_alloc_fixed (D.22605, statics_gc_descr);
            vt->vtable[D.22530] = D.22606;
            D.22530 = class->vtable_size;
            D.22607 = vt->vtable[D.22530];
            mono_domain_add_class_static_data (domain, class, D.22607, 0B);
            if (&default_bitmap != bitmap) goto <D.22608>; else goto <D.22609>;
            <D.22608>:
            monoeg_g_free (bitmap);
            <D.22609>:
          }
        finally
          {
            max_set = {CLOBBER};
            default_bitmap = {CLOBBER};
          }
      }
      goto <D.22610>;
      <D.22602>:
      D.22530 = class->vtable_size;
      D.22611 = mono_domain_alloc0 (domain, class_size);
      vt->vtable[D.22530] = D.22611;
      <D.22610>:
      vt->has_static_fields = 1;
      D.22612 = mono_stats.class_static_data_size;
      D.22613 = (long unsigned int) class_size;
      D.22614 = D.22612 + D.22613;
      mono_stats.class_static_data_size = D.22614;
      <D.22599>:
      cindex = 4294967295;
      iter = 0B;
      goto <D.20048>;
      <D.20069>:
      D.22615 = field->type;
      D.22616 = D.22615->attrs;
      D.22617 = (int) D.22616;
      D.22618 = D.22617 & 16;
      if (D.22618 == 0) goto <D.22619>; else goto <D.22620>;
      <D.22619>:
      // predicted unlikely by continue predictor.
      goto <D.20048>;
      <D.22620>:
      D.22615 = field->type;
      D.22616 = D.22615->attrs;
      D.22617 = (int) D.22616;
      D.22621 = D.22617 & 1536;
      if (D.22621 != 0) goto <D.22622>; else goto <D.22623>;
      <D.22622>:
      {
        size_t __s1_len;
        size_t __s2_len;

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

          __s2 = mono_field_get_name (field);
          D.22627 = "_Deleted";
          D.22628 = MEM[(const unsigned char *)D.22627];
          D.22629 = (int) D.22628;
          D.22630 = *__s2;
          D.22631 = (int) D.22630;
          __result = D.22629 - D.22631;
          {
            if (__s2_len != 0) goto <D.22632>; else goto <D.22633>;
            <D.22632>:
            if (__result == 0) goto <D.22634>; else goto <D.22635>;
            <D.22634>:
            D.22636 = &MEM[(void *)"_Deleted" + 1B];
            D.22637 = *D.22636;
            D.22638 = (int) D.22637;
            D.22639 = __s2 + 1;
            D.22640 = *D.22639;
            D.22641 = (int) D.22640;
            __result = D.22638 - D.22641;
            if (__s2_len > 1) goto <D.22642>; else goto <D.22643>;
            <D.22642>:
            if (__result == 0) goto <D.22644>; else goto <D.22645>;
            <D.22644>:
            D.22646 = &MEM[(void *)"_Deleted" + 2B];
            D.22647 = *D.22646;
            D.22648 = (int) D.22647;
            D.22649 = __s2 + 2;
            D.22650 = *D.22649;
            D.22651 = (int) D.22650;
            __result = D.22648 - D.22651;
            if (__s2_len > 2) goto <D.22652>; else goto <D.22653>;
            <D.22652>:
            if (__result == 0) goto <D.22654>; else goto <D.22655>;
            <D.22654>:
            D.22656 = &MEM[(void *)"_Deleted" + 3B];
            D.22657 = *D.22656;
            D.22658 = (int) D.22657;
            D.22659 = __s2 + 3;
            D.22660 = *D.22659;
            D.22661 = (int) D.22660;
            __result = D.22658 - D.22661;
            <D.22655>:
            <D.22653>:
            <D.22645>:
            <D.22643>:
            <D.22635>:
            <D.22633>:
          }
          D.20056 = __result;
        }
        iftmp.60 = -D.20056;
        goto <D.22662>;
        <D.22626>:
        D.22663 = mono_field_get_name (field);
        iftmp.60 = __builtin_strcmp (D.22663, "_Deleted");
        <D.22662>:
        D.20057 = iftmp.60;
      }
      if (D.20057 == 0) goto <D.22664>; else goto <D.22665>;
      <D.22664>:
      // predicted unlikely by continue predictor.
      goto <D.20048>;
      <D.22665>:
      <D.22623>:
      D.22615 = field->type;
      D.22616 = D.22615->attrs;
      D.22617 = (int) D.22616;
      D.22666 = D.22617 & 64;
      if (D.22666 == 0) goto <D.22667>; else goto <D.22668>;
      <D.22667>:
      {
        gint32 special_static;

        D.22483 = BIT_FIELD_REF <*class, 64, 256>;
        D.22670 = D.22483 & 536870912;
        if (D.22670 == 0) goto <D.22671>; else goto <D.22672>;
        <D.22671>:
        iftmp.61 = field_is_special_static (class, field);
        goto <D.22673>;
        <D.22672>:
        iftmp.61 = 0;
        <D.22673>:
        special_static = iftmp.61;
        if (special_static != 0) goto <D.22674>; else goto <D.22675>;
        <D.22674>:
        {
          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.22615 = field->type;
              D.22676 = mono_type_is_reference (D.22615);
              if (D.22676 != 0) goto <D.22677>; else goto <D.22678>;
              <D.22677>:
              default_bitmap[0] = 1;
              numbits = 1;
              bitmap = &default_bitmap;
              goto <D.22679>;
              <D.22678>:
              D.22615 = field->type;
              D.22680 = mono_type_is_struct (D.22615);
              if (D.22680 != 0) goto <D.22681>; else goto <D.22682>;
              <D.22681>:
              D.22615 = field->type;
              fclass = mono_class_from_mono_type (D.22615);
              bitmap = compute_class_bitmap (fclass, &default_bitmap, 256, -2, &max_set, 0);
              max_set.62 = max_set;
              numbits = max_set.62 + 1;
              goto <D.22684>;
              <D.22682>:
              default_bitmap[0] = 0;
              numbits = 0;
              bitmap = &default_bitmap;
              <D.22684>:
              <D.22679>:
              D.22615 = field->type;
              D.22685 = mono_type_size (D.22615, &align);
              size = (guint32) D.22685;
              special_static.63 = (unsigned int) special_static;
              align.64 = align;
              align.65 = (unsigned int) align.64;
              offset = mono_alloc_special_static_data (special_static.63, size, align.65, bitmap, numbits);
              D.22689 = domain->special_static_fields;
              if (D.22689 == 0B) goto <D.22690>; else goto <D.22691>;
              <D.22690>:
              D.22692 = monoeg_g_hash_table_new (0B, 0B);
              domain->special_static_fields = D.22692;
              <D.22691>:
              D.22689 = domain->special_static_fields;
              D.22693 = (long unsigned int) offset;
              D.22694 = (void *) D.22693;
              monoeg_g_hash_table_insert_replace (D.22689, field, D.22694, 0);
              if (&default_bitmap != bitmap) goto <D.22695>; else goto <D.22696>;
              <D.22695>:
              monoeg_g_free (bitmap);
              <D.22696>:
              field->offset = -1;
              // predicted unlikely by continue predictor.
              goto <D.20048>;
            }
          finally
            {
              align = {CLOBBER};
              default_bitmap = {CLOBBER};
              max_set = {CLOBBER};
            }
        }
        <D.22675>:
      }
      <D.22668>:
      D.22615 = field->type;
      D.22616 = D.22615->attrs;
      D.22617 = (int) D.22616;
      D.22697 = D.22617 & 256;
      if (D.22697 != 0) goto <D.22698>; else goto <D.22699>;
      <D.22698>:
      {
        struct MonoClass * fklass;
        const char * data;

        D.22615 = field->type;
        fklass = mono_class_from_mono_type (D.22615);
        data = mono_field_get_data (field);
        D.22615 = field->type;
        D.22616 = D.22615->attrs;
        D.22700 = (signed short) D.22616;
        D.22701 = D.22700 < 0;
        D.22702 = (long int) D.22701;
        D.22703 = __builtin_expect (D.22702, 0);
        if (D.22703 != 0) goto <D.22704>; else goto <D.22705>;
        <D.22704>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 2043, "!(field->type->attrs & FIELD_ATTRIBUTE_HAS_DEFAULT)");
        <D.22705>:
        D.22706 = mono_vtable_get_static_field_data (vt);
        D.22707 = field->offset;
        D.22708 = (sizetype) D.22707;
        t = D.22706 + D.22708;
        if (data == 0B) goto <D.22709>; else goto <D.22710>;
        <D.22709>:
        // predicted unlikely by continue predictor.
        goto <D.20048>;
        <D.22710>:
        D.22711 = BIT_FIELD_REF <*fklass, 64, 256>;
        D.22712 = D.22711 & 8;
        if (D.22712 != 0) goto <D.22713>; else goto <D.22714>;
        <D.22713>:
        D.22715 = mono_class_value_size (fklass, 0B);
        D.22716 = (long unsigned int) D.22715;
        memcpy (t, data, D.22716);
        goto <D.22717>;
        <D.22714>:
        D.22721 = fklass->byval_arg.type;
        if (D.22721 != 15) goto <D.22722>; else goto <D.22719>;
        <D.22722>:
        D.22721 = fklass->byval_arg.type;
        if (D.22721 != 27) goto <D.22723>; else goto <D.22719>;
        <D.22723>:
        iftmp.66 = 1;
        goto <D.22720>;
        <D.22719>:
        iftmp.66 = 0;
        <D.22720>:
        D.22724 = iftmp.66 != 0;
        D.22725 = (long int) D.22724;
        D.22726 = __builtin_expect (D.22725, 0);
        if (D.22726 != 0) goto <D.22727>; else goto <D.22728>;
        <D.22727>:
        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.22728>:
        D.22729 = MEM[(char *)data];
        *t = D.22729;
        <D.22717>:
        // predicted unlikely by continue predictor.
        goto <D.20048>;
      }
      <D.22699>:
      <D.20048>:
      field = mono_class_get_fields (class, &iter);
      if (field != 0B) goto <D.20069>; else goto <D.20070>;
      <D.20070>:
      D.22568 = class->max_interface_id;
      vt->max_interface_id = D.22568;
      D.22730 = class->interface_bitmap;
      vt->interface_bitmap = D.22730;
      imt_thunk_builder.58 = imt_thunk_builder;
      if (imt_thunk_builder.58 == 0B) goto <D.22731>; else goto <D.22732>;
      <D.22731>:
      i = 0;
      goto <D.20074>;
      <D.20073>:
      {
        int interface_id;
        int slot;

        D.22733 = class->interfaces_packed;
        D.22734 = (long unsigned int) i;
        D.22735 = D.22734 * 8;
        D.22736 = D.22733 + D.22735;
        D.22737 = *D.22736;
        D.22738 = D.22737->interface_id;
        interface_id = (int) D.22738;
        D.22739 = class->interface_offsets_packed;
        D.22734 = (long unsigned int) i;
        D.22740 = D.22734 * 2;
        D.22741 = D.22739 + D.22740;
        D.22742 = *D.22741;
        slot = (int) D.22742;
        D.22568 = class->max_interface_id;
        D.22569 = (int) D.22568;
        D.22743 = D.22569 - interface_id;
        D.22744 = (long unsigned int) D.22743;
        D.22745 = D.22744 * 8;
        D.22746 = interface_offsets + D.22745;
        D.22747 = &vt->vtable[slot];
        *D.22746 = D.22747;
      }
      i = i + 1;
      <D.20074>:
      D.22560 = class->interface_offsets_count;
      D.22748 = (int) D.22560;
      if (D.22748 > i) goto <D.20073>; else goto <D.20075>;
      <D.20075>:
      <D.22732>:
      D.22749 = callbacks.get_vtable_trampoline;
      if (D.22749 != 0B) goto <D.22750>; else goto <D.22751>;
      <D.22750>:
      i = 0;
      goto <D.20077>;
      <D.20076>:
      D.22749 = callbacks.get_vtable_trampoline;
      D.22752 = D.22749 (i);
      vt->vtable[i] = D.22752;
      i = i + 1;
      <D.20077>:
      D.22530 = class->vtable_size;
      if (D.22530 > i) goto <D.20076>; else goto <D.20078>;
      <D.20078>:
      goto <D.22753>;
      <D.22751>:
      mono_class_setup_vtable (class);
      i = 0;
      goto <D.20081>;
      <D.20080>:
      {
        struct MonoMethod * cm;

        D.22536 = class->vtable;
        D.22734 = (long unsigned int) i;
        D.22735 = D.22734 * 8;
        D.22754 = D.22536 + D.22735;
        cm = *D.22754;
        if (cm != 0B) goto <D.22755>; else goto <D.22756>;
        <D.22755>:
        arch_create_jit_trampoline.67 = arch_create_jit_trampoline;
        D.22758 = arch_create_jit_trampoline.67 (cm);
        vt->vtable[i] = D.22758;
        <D.22756>:
      }
      i = i + 1;
      <D.20081>:
      D.22530 = class->vtable_size;
      if (D.22530 > i) goto <D.20080>; else goto <D.20082>;
      <D.20082>:
      <D.22753>:
      imt_thunk_builder.58 = imt_thunk_builder;
      if (imt_thunk_builder.58 != 0B) goto <D.22759>; else goto <D.22760>;
      <D.22759>:
      if (imt_table_bytes != 0) goto <D.22761>; else goto <D.22762>;
      <D.22761>:
      D.22763 = callbacks.get_imt_trampoline;
      if (D.22763 != 0B) goto <D.22764>; else goto <D.22765>;
      <D.22764>:
      i = 0;
      goto <D.20084>;
      <D.20083>:
      D.22734 = (long unsigned int) i;
      D.22735 = D.22734 * 8;
      D.22766 = interface_offsets + D.22735;
      D.22763 = callbacks.get_imt_trampoline;
      D.22767 = D.22763 (i);
      *D.22766 = D.22767;
      i = i + 1;
      <D.20084>:
      if (i <= 18) goto <D.20083>; else goto <D.20085>;
      <D.20085>:
      goto <D.22768>;
      <D.22765>:
      build_imt (class, vt, domain, interface_offsets, 0B);
      <D.22768>:
      <D.22762>:
      <D.22760>:
      D.22769 = mono_defaults.monotype_class;
      if (D.22769 != class) goto <D.22770>; else goto <D.22771>;
      <D.22770>:
      D.22772 = &class->byval_arg;
      D.22773 = mono_type_get_object (domain, D.22772);
      vt->type = D.22773;
      D.22774 = vt->type;
      D.22775 = mono_object_get_class (D.22774);
      D.22769 = mono_defaults.monotype_class;
      if (D.22775 != D.22769) goto <D.22776>; else goto <D.22777>;
      <D.22776>:
      D.22778 = mono_gc_is_moving ();
      if (D.22778 != 0) goto <D.22779>; else goto <D.22780>;
      <D.22779>:
      if (0 != 0) goto <D.22781>; else goto <D.22782>;
      <D.22781>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 2114, "sizeof (vt->type) == sizeof (MonoObject*)");
      <D.22782>:
      D.22783 = &vt->type;
      D.22784 = mono_gc_make_root_descr_all_refs (1);
      mono_gc_register_root (D.22783, 8, D.22784);
      <D.22780>:
      <D.22777>:
      <D.22771>:
      D.22483 = BIT_FIELD_REF <*class, 64, 256>;
      D.22785 = D.22483 & 8388608;
      D.22786 = D.22785 != 0;
      vt->remote = D.22786;
      D.22787 = domain->class_vtable_array;
      monoeg_g_ptr_array_add (D.22787, vt);
      mono_memory_barrier ();
      old_info = class->runtime_info;
      if (old_info != 0B) goto <D.22790>; else goto <D.22788>;
      <D.22790>:
      D.22791 = old_info->max_domain;
      D.22792 = (int) D.22791;
      D.22469 = domain->domain_id;
      if (D.22792 >= D.22469) goto <D.22793>; else goto <D.22788>;
      <D.22793>:
      D.22469 = domain->domain_id;
      old_info->domain_vtables[D.22469] = vt;
      goto <D.22789>;
      <D.22788>:
      {
        int new_size;

        new_size = domain->domain_id;
        if (old_info != 0B) goto <D.22794>; else goto <D.22795>;
        <D.22794>:
        D.22791 = old_info->max_domain;
        D.22796 = (int) D.22791;
        new_size = MAX_EXPR <D.22796, new_size>;
        <D.22795>:
        new_size = new_size + 1;
        i = 2;
        goto <D.20088>;
        <D.20087>:
        i = i << 1;
        <D.20088>:
        if (new_size > i) goto <D.20087>; else goto <D.20089>;
        <D.20089>:
        new_size = i;
        D.22797 = class->image;
        D.22798 = (long unsigned int) new_size;
        D.22799 = D.22798 + 1;
        D.22800 = (unsigned int) D.22799;
        D.22801 = D.22800 * 8;
        runtime_info = mono_image_alloc0 (D.22797, D.22801);
        D.22802 = (short unsigned int) new_size;
        D.22803 = D.22802 + 65535;
        runtime_info->max_domain = D.22803;
        if (old_info != 0B) goto <D.22804>; else goto <D.22805>;
        <D.22804>:
        D.22806 = &runtime_info->domain_vtables;
        D.22807 = &old_info->domain_vtables;
        D.22791 = old_info->max_domain;
        D.22796 = (int) D.22791;
        D.22808 = D.22796 + 1;
        D.22809 = (long unsigned int) D.22808;
        D.22810 = D.22809 * 8;
        memcpy (D.22806, D.22807, D.22810);
        <D.22805>:
        D.22469 = domain->domain_id;
        runtime_info->domain_vtables[D.22469] = vt;
        mono_memory_barrier ();
        class->runtime_info = runtime_info;
      }
      <D.22789>:
      D.22769 = mono_defaults.monotype_class;
      if (D.22769 == class) goto <D.22811>; else goto <D.22812>;
      <D.22811>:
      D.22772 = &class->byval_arg;
      D.22813 = mono_type_get_object (domain, D.22772);
      vt->type = D.22813;
      D.22774 = vt->type;
      D.22814 = mono_object_get_class (D.22774);
      D.22769 = mono_defaults.monotype_class;
      if (D.22814 != D.22769) goto <D.22815>; else goto <D.22816>;
      <D.22815>:
      D.22817 = mono_gc_is_moving ();
      if (D.22817 != 0) goto <D.22818>; else goto <D.22819>;
      <D.22818>:
      if (0 != 0) goto <D.22820>; else goto <D.22821>;
      <D.22820>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 2168, "sizeof (vt->type) == sizeof (MonoObject*)");
      <D.22821>:
      D.22783 = &vt->type;
      D.22822 = mono_gc_make_root_descr_all_refs (1);
      mono_gc_register_root (D.22783, 8, D.22822);
      <D.22819>:
      <D.22816>:
      <D.22812>:
      {
        int ret;

        D.22457 = &domain->lock.mutex;
        ret = pthread_mutex_unlock (D.22457);
        if (ret != 0) goto <D.22823>; else goto <D.22824>;
        <D.22823>:
        monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
        <D.22824>:
        D.22825 = ret != 0;
        D.22826 = (long int) D.22825;
        D.22827 = __builtin_expect (D.22826, 0);
        if (D.22827 != 0) goto <D.22828>; else goto <D.22829>;
        <D.22828>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 2171, "ret == 0");
        <D.22829>:
      }
      mono_loader_unlock ();
      D.22830 = mono_is_security_manager_active ();
      if (D.22830 != 0) goto <D.22831>; else goto <D.22832>;
      <D.22831>:
      D.22491 = class->exception_type;
      if (D.22491 == 2) goto <D.22833>; else goto <D.22834>;
      <D.22833>:
      if (raise_on_error != 0) goto <D.22835>; else goto <D.22836>;
      <D.22835>:
      D.22837 = mono_class_get_exception_for_failure (class);
      mono_raise_exception (D.22837);
      <D.22836>:
      <D.22834>:
      <D.22832>:
      D.22838 = class->parent;
      if (D.22838 != 0B) goto <D.22839>; else goto <D.22840>;
      <D.22839>:
      D.22838 = class->parent;
      mono_class_vtable_full (domain, D.22838, raise_on_error);
      <D.22840>:
      D.22482 = vt;
      return D.22482;
    }
  finally
    {
      iter = {CLOBBER};
    }
}


field_is_special_static (struct MonoClass * fklass, struct MonoClassField * field)
{
  gint32 D.22846;
  struct MonoMethod * D.22847;
  struct MonoImage * D.22848;
  struct MonoImage * D.22849;
  int D.19744;
  int iftmp.68;
  int D.19743;
  const char[22] * D.22855;
  unsigned char D.22856;
  int D.22857;
  unsigned char D.22858;
  int D.22859;
  const unsigned char * D.22864;
  unsigned char D.22865;
  int D.22866;
  const unsigned char * D.22867;
  unsigned char D.22868;
  int D.22869;
  const unsigned char * D.22874;
  unsigned char D.22875;
  int D.22876;
  const unsigned char * D.22877;
  unsigned char D.22878;
  int D.22879;
  const unsigned char * D.22884;
  unsigned char D.22885;
  int D.22886;
  const unsigned char * D.22887;
  unsigned char D.22888;
  int D.22889;
  const char * D.22891;
  int D.19753;
  int iftmp.69;
  int D.19752;
  const char[23] * D.22897;
  unsigned char D.22898;
  int D.22899;
  unsigned char D.22900;
  int D.22901;
  const unsigned char * D.22906;
  unsigned char D.22907;
  int D.22908;
  const unsigned char * D.22909;
  unsigned char D.22910;
  int D.22911;
  const unsigned char * D.22916;
  unsigned char D.22917;
  int D.22918;
  const unsigned char * D.22919;
  unsigned char D.22920;
  int D.22921;
  const unsigned char * D.22926;
  unsigned char D.22927;
  int D.22928;
  const unsigned char * D.22929;
  unsigned char D.22930;
  int D.22931;
  int D.22935;
  struct MonoCustomAttrInfo * ainfo;
  int i;

  ainfo = mono_custom_attrs_from_field (fklass, field);
  if (ainfo == 0B) goto <D.22844>; else goto <D.22845>;
  <D.22844>:
  D.22846 = 0;
  return D.22846;
  <D.22845>:
  i = 0;
  goto <D.19755>;
  <D.19754>:
  {
    struct MonoClass * klass;

    D.22847 = ainfo->attrs[i].ctor;
    klass = D.22847->klass;
    D.22848 = klass->image;
    D.22849 = mono_defaults.corlib;
    if (D.22848 == D.22849) goto <D.22850>; else goto <D.22851>;
    <D.22850>:
    {
      size_t __s1_len;
      size_t __s2_len;

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

        __s2 = klass->name;
        D.22855 = "ThreadStaticAttribute";
        D.22856 = MEM[(const unsigned char *)D.22855];
        D.22857 = (int) D.22856;
        D.22858 = *__s2;
        D.22859 = (int) D.22858;
        __result = D.22857 - D.22859;
        {
          if (__s2_len != 0) goto <D.22860>; else goto <D.22861>;
          <D.22860>:
          if (__result == 0) goto <D.22862>; else goto <D.22863>;
          <D.22862>:
          D.22864 = &MEM[(void *)"ThreadStaticAttribute" + 1B];
          D.22865 = *D.22864;
          D.22866 = (int) D.22865;
          D.22867 = __s2 + 1;
          D.22868 = *D.22867;
          D.22869 = (int) D.22868;
          __result = D.22866 - D.22869;
          if (__s2_len > 1) goto <D.22870>; else goto <D.22871>;
          <D.22870>:
          if (__result == 0) goto <D.22872>; else goto <D.22873>;
          <D.22872>:
          D.22874 = &MEM[(void *)"ThreadStaticAttribute" + 2B];
          D.22875 = *D.22874;
          D.22876 = (int) D.22875;
          D.22877 = __s2 + 2;
          D.22878 = *D.22877;
          D.22879 = (int) D.22878;
          __result = D.22876 - D.22879;
          if (__s2_len > 2) goto <D.22880>; else goto <D.22881>;
          <D.22880>:
          if (__result == 0) goto <D.22882>; else goto <D.22883>;
          <D.22882>:
          D.22884 = &MEM[(void *)"ThreadStaticAttribute" + 3B];
          D.22885 = *D.22884;
          D.22886 = (int) D.22885;
          D.22887 = __s2 + 3;
          D.22888 = *D.22887;
          D.22889 = (int) D.22888;
          __result = D.22886 - D.22889;
          <D.22883>:
          <D.22881>:
          <D.22873>:
          <D.22871>:
          <D.22863>:
          <D.22861>:
        }
        D.19743 = __result;
      }
      iftmp.68 = -D.19743;
      goto <D.22890>;
      <D.22854>:
      D.22891 = klass->name;
      iftmp.68 = __builtin_strcmp (D.22891, "ThreadStaticAttribute");
      <D.22890>:
      D.19744 = iftmp.68;
    }
    if (D.19744 == 0) goto <D.22892>; else goto <D.22893>;
    <D.22892>:
    mono_custom_attrs_free (ainfo);
    D.22846 = 1;
    return D.22846;
    <D.22893>:
    {
      size_t __s1_len;
      size_t __s2_len;

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

        __s2 = klass->name;
        D.22897 = "ContextStaticAttribute";
        D.22898 = MEM[(const unsigned char *)D.22897];
        D.22899 = (int) D.22898;
        D.22900 = *__s2;
        D.22901 = (int) D.22900;
        __result = D.22899 - D.22901;
        {
          if (__s2_len != 0) goto <D.22902>; else goto <D.22903>;
          <D.22902>:
          if (__result == 0) goto <D.22904>; else goto <D.22905>;
          <D.22904>:
          D.22906 = &MEM[(void *)"ContextStaticAttribute" + 1B];
          D.22907 = *D.22906;
          D.22908 = (int) D.22907;
          D.22909 = __s2 + 1;
          D.22910 = *D.22909;
          D.22911 = (int) D.22910;
          __result = D.22908 - D.22911;
          if (__s2_len > 1) goto <D.22912>; else goto <D.22913>;
          <D.22912>:
          if (__result == 0) goto <D.22914>; else goto <D.22915>;
          <D.22914>:
          D.22916 = &MEM[(void *)"ContextStaticAttribute" + 2B];
          D.22917 = *D.22916;
          D.22918 = (int) D.22917;
          D.22919 = __s2 + 2;
          D.22920 = *D.22919;
          D.22921 = (int) D.22920;
          __result = D.22918 - D.22921;
          if (__s2_len > 2) goto <D.22922>; else goto <D.22923>;
          <D.22922>:
          if (__result == 0) goto <D.22924>; else goto <D.22925>;
          <D.22924>:
          D.22926 = &MEM[(void *)"ContextStaticAttribute" + 3B];
          D.22927 = *D.22926;
          D.22928 = (int) D.22927;
          D.22929 = __s2 + 3;
          D.22930 = *D.22929;
          D.22931 = (int) D.22930;
          __result = D.22928 - D.22931;
          <D.22925>:
          <D.22923>:
          <D.22915>:
          <D.22913>:
          <D.22905>:
          <D.22903>:
        }
        D.19752 = __result;
      }
      iftmp.69 = -D.19752;
      goto <D.22932>;
      <D.22896>:
      D.22891 = klass->name;
      iftmp.69 = __builtin_strcmp (D.22891, "ContextStaticAttribute");
      <D.22932>:
      D.19753 = iftmp.69;
    }
    if (D.19753 == 0) goto <D.22933>; else goto <D.22934>;
    <D.22933>:
    mono_custom_attrs_free (ainfo);
    D.22846 = 2;
    return D.22846;
    <D.22934>:
    <D.22851>:
  }
  i = i + 1;
  <D.19755>:
  D.22935 = ainfo->num_attrs;
  if (D.22935 > i) goto <D.19754>; else goto <D.19756>;
  <D.19756>:
  mono_custom_attrs_free (ainfo);
  D.22846 = 0;
  return D.22846;
}


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.22937;
  long int D.22938;
  long int D.22939;
  short unsigned int D.22944;
  int D.22945;
  int D.22946;
  struct MonoVTable * D.22949;
  struct MonoVTable * D.22952;
  struct MonoClassRuntimeInfo * runtime_info;

  D.22937 = class == 0B;
  D.22938 = (long int) D.22937;
  D.22939 = __builtin_expect (D.22938, 0);
  if (D.22939 != 0) goto <D.22940>; else goto <D.22941>;
  <D.22940>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 1832, "class");
  <D.22941>:
  runtime_info = class->runtime_info;
  if (runtime_info != 0B) goto <D.22942>; else goto <D.22943>;
  <D.22942>:
  D.22944 = runtime_info->max_domain;
  D.22945 = (int) D.22944;
  D.22946 = domain->domain_id;
  if (D.22945 >= D.22946) goto <D.22947>; else goto <D.22948>;
  <D.22947>:
  D.22946 = domain->domain_id;
  D.22949 = runtime_info->domain_vtables[D.22946];
  if (D.22949 != 0B) goto <D.22950>; else goto <D.22951>;
  <D.22950>:
  D.22946 = domain->domain_id;
  D.22952 = runtime_info->domain_vtables[D.22946];
  return D.22952;
  <D.22951>:
  <D.22948>:
  <D.22943>:
  D.22952 = 0B;
  return D.22952;
}


mono_class_field_is_special_static (struct MonoClassField * field)
{
  struct MonoType * D.22954;
  short unsigned int D.22955;
  int D.22956;
  int D.22957;
  gboolean D.22960;
  int D.22961;
  int D.20165;
  int iftmp.70;
  int D.20164;
  const char[9] * D.22967;
  unsigned char D.22968;
  int D.22969;
  unsigned char D.22970;
  int D.22971;
  const unsigned char * D.22976;
  unsigned char D.22977;
  int D.22978;
  const unsigned char * D.22979;
  unsigned char D.22980;
  int D.22981;
  const unsigned char * D.22986;
  unsigned char D.22987;
  int D.22988;
  const unsigned char * D.22989;
  unsigned char D.22990;
  int D.22991;
  const unsigned char * D.22996;
  unsigned char D.22997;
  int D.22998;
  const unsigned char * D.22999;
  unsigned char D.23000;
  int D.23001;
  const char * D.23003;
  int D.23006;
  struct MonoClass * D.23009;
  int D.23010;

  D.22954 = field->type;
  D.22955 = D.22954->attrs;
  D.22956 = (int) D.22955;
  D.22957 = D.22956 & 16;
  if (D.22957 == 0) goto <D.22958>; else goto <D.22959>;
  <D.22958>:
  D.22960 = 0;
  return D.22960;
  <D.22959>:
  D.22954 = field->type;
  D.22955 = D.22954->attrs;
  D.22956 = (int) D.22955;
  D.22961 = D.22956 & 1536;
  if (D.22961 != 0) goto <D.22962>; else goto <D.22963>;
  <D.22962>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = mono_field_get_name (field);
      D.22967 = "_Deleted";
      D.22968 = MEM[(const unsigned char *)D.22967];
      D.22969 = (int) D.22968;
      D.22970 = *__s2;
      D.22971 = (int) D.22970;
      __result = D.22969 - D.22971;
      {
        if (__s2_len != 0) goto <D.22972>; else goto <D.22973>;
        <D.22972>:
        if (__result == 0) goto <D.22974>; else goto <D.22975>;
        <D.22974>:
        D.22976 = &MEM[(void *)"_Deleted" + 1B];
        D.22977 = *D.22976;
        D.22978 = (int) D.22977;
        D.22979 = __s2 + 1;
        D.22980 = *D.22979;
        D.22981 = (int) D.22980;
        __result = D.22978 - D.22981;
        if (__s2_len > 1) goto <D.22982>; else goto <D.22983>;
        <D.22982>:
        if (__result == 0) goto <D.22984>; else goto <D.22985>;
        <D.22984>:
        D.22986 = &MEM[(void *)"_Deleted" + 2B];
        D.22987 = *D.22986;
        D.22988 = (int) D.22987;
        D.22989 = __s2 + 2;
        D.22990 = *D.22989;
        D.22991 = (int) D.22990;
        __result = D.22988 - D.22991;
        if (__s2_len > 2) goto <D.22992>; else goto <D.22993>;
        <D.22992>:
        if (__result == 0) goto <D.22994>; else goto <D.22995>;
        <D.22994>:
        D.22996 = &MEM[(void *)"_Deleted" + 3B];
        D.22997 = *D.22996;
        D.22998 = (int) D.22997;
        D.22999 = __s2 + 3;
        D.23000 = *D.22999;
        D.23001 = (int) D.23000;
        __result = D.22998 - D.23001;
        <D.22995>:
        <D.22993>:
        <D.22985>:
        <D.22983>:
        <D.22975>:
        <D.22973>:
      }
      D.20164 = __result;
    }
    iftmp.70 = -D.20164;
    goto <D.23002>;
    <D.22966>:
    D.23003 = mono_field_get_name (field);
    iftmp.70 = __builtin_strcmp (D.23003, "_Deleted");
    <D.23002>:
    D.20165 = iftmp.70;
  }
  if (D.20165 == 0) goto <D.23004>; else goto <D.23005>;
  <D.23004>:
  D.22960 = 0;
  return D.22960;
  <D.23005>:
  <D.22963>:
  D.22954 = field->type;
  D.22955 = D.22954->attrs;
  D.22956 = (int) D.22955;
  D.23006 = D.22956 & 64;
  if (D.23006 == 0) goto <D.23007>; else goto <D.23008>;
  <D.23007>:
  D.23009 = field->parent;
  D.23010 = field_is_special_static (D.23009, field);
  if (D.23010 != 0) goto <D.23011>; else goto <D.23012>;
  <D.23011>:
  D.22960 = 1;
  return D.22960;
  <D.23012>:
  <D.23008>:
  D.22960 = 0;
  return D.22960;
}


mono_class_field_get_special_static_type (struct MonoClassField * field)
{
  struct MonoType * D.23014;
  short unsigned int D.23015;
  int D.23016;
  int D.23017;
  guint32 D.23020;
  int D.23021;
  int D.20177;
  int iftmp.71;
  int D.20176;
  const char[9] * D.23027;
  unsigned char D.23028;
  int D.23029;
  unsigned char D.23030;
  int D.23031;
  const unsigned char * D.23036;
  unsigned char D.23037;
  int D.23038;
  const unsigned char * D.23039;
  unsigned char D.23040;
  int D.23041;
  const unsigned char * D.23046;
  unsigned char D.23047;
  int D.23048;
  const unsigned char * D.23049;
  unsigned char D.23050;
  int D.23051;
  const unsigned char * D.23056;
  unsigned char D.23057;
  int D.23058;
  const unsigned char * D.23059;
  unsigned char D.23060;
  int D.23061;
  const char * D.23063;
  int D.23066;
  struct MonoClass * D.23069;
  int D.23070;

  D.23014 = field->type;
  D.23015 = D.23014->attrs;
  D.23016 = (int) D.23015;
  D.23017 = D.23016 & 16;
  if (D.23017 == 0) goto <D.23018>; else goto <D.23019>;
  <D.23018>:
  D.23020 = 0;
  return D.23020;
  <D.23019>:
  D.23014 = field->type;
  D.23015 = D.23014->attrs;
  D.23016 = (int) D.23015;
  D.23021 = D.23016 & 1536;
  if (D.23021 != 0) goto <D.23022>; else goto <D.23023>;
  <D.23022>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = mono_field_get_name (field);
      D.23027 = "_Deleted";
      D.23028 = MEM[(const unsigned char *)D.23027];
      D.23029 = (int) D.23028;
      D.23030 = *__s2;
      D.23031 = (int) D.23030;
      __result = D.23029 - D.23031;
      {
        if (__s2_len != 0) goto <D.23032>; else goto <D.23033>;
        <D.23032>:
        if (__result == 0) goto <D.23034>; else goto <D.23035>;
        <D.23034>:
        D.23036 = &MEM[(void *)"_Deleted" + 1B];
        D.23037 = *D.23036;
        D.23038 = (int) D.23037;
        D.23039 = __s2 + 1;
        D.23040 = *D.23039;
        D.23041 = (int) D.23040;
        __result = D.23038 - D.23041;
        if (__s2_len > 1) goto <D.23042>; else goto <D.23043>;
        <D.23042>:
        if (__result == 0) goto <D.23044>; else goto <D.23045>;
        <D.23044>:
        D.23046 = &MEM[(void *)"_Deleted" + 2B];
        D.23047 = *D.23046;
        D.23048 = (int) D.23047;
        D.23049 = __s2 + 2;
        D.23050 = *D.23049;
        D.23051 = (int) D.23050;
        __result = D.23048 - D.23051;
        if (__s2_len > 2) goto <D.23052>; else goto <D.23053>;
        <D.23052>:
        if (__result == 0) goto <D.23054>; else goto <D.23055>;
        <D.23054>:
        D.23056 = &MEM[(void *)"_Deleted" + 3B];
        D.23057 = *D.23056;
        D.23058 = (int) D.23057;
        D.23059 = __s2 + 3;
        D.23060 = *D.23059;
        D.23061 = (int) D.23060;
        __result = D.23058 - D.23061;
        <D.23055>:
        <D.23053>:
        <D.23045>:
        <D.23043>:
        <D.23035>:
        <D.23033>:
      }
      D.20176 = __result;
    }
    iftmp.71 = -D.20176;
    goto <D.23062>;
    <D.23026>:
    D.23063 = mono_field_get_name (field);
    iftmp.71 = __builtin_strcmp (D.23063, "_Deleted");
    <D.23062>:
    D.20177 = iftmp.71;
  }
  if (D.20177 == 0) goto <D.23064>; else goto <D.23065>;
  <D.23064>:
  D.23020 = 0;
  return D.23020;
  <D.23065>:
  <D.23023>:
  D.23014 = field->type;
  D.23015 = D.23014->attrs;
  D.23016 = (int) D.23015;
  D.23066 = D.23016 & 64;
  if (D.23066 == 0) goto <D.23067>; else goto <D.23068>;
  <D.23067>:
  D.23069 = field->parent;
  D.23070 = field_is_special_static (D.23069, field);
  D.23020 = (guint32) D.23070;
  return D.23020;
  <D.23068>:
  D.23020 = 0;
  return D.23020;
}


mono_class_has_special_static_fields (struct MonoClass * klass)
{
  struct MonoClass * D.23072;
  _Bool D.23073;
  long int D.23074;
  long int D.23075;
  int D.23078;
  gboolean D.23081;
  struct MonoClassField * field;
  void * iter;

  try
    {
      iter = 0B;
      goto <D.20184>;
      <D.20183>:
      D.23072 = field->parent;
      D.23073 = D.23072 != klass;
      D.23074 = (long int) D.23073;
      D.23075 = __builtin_expect (D.23074, 0);
      if (D.23075 != 0) goto <D.23076>; else goto <D.23077>;
      <D.23076>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 2420, "field->parent == klass");
      <D.23077>:
      D.23078 = mono_class_field_is_special_static (field);
      if (D.23078 != 0) goto <D.23079>; else goto <D.23080>;
      <D.23079>:
      D.23081 = 1;
      return D.23081;
      <D.23080>:
      <D.20184>:
      field = mono_class_get_fields (klass, &iter);
      if (field != 0B) goto <D.20183>; else goto <D.20185>;
      <D.20185>:
      D.23081 = 0;
      return D.23081;
    }
  finally
    {
      iter = {CLOBBER};
    }
}


mono_remote_class (struct MonoDomain * domain, struct MonoString * class_name, struct MonoClass * proxy_class)
{
  union mono_mutex_t * D.23084;
  _Bool D.23087;
  long int D.23088;
  long int D.23089;
  struct GHashTable * D.23092;
  _Bool D.23097;
  long int D.23098;
  long int D.23099;
  struct MonoRemoteClass * D.23102;
  struct MonoMemPool * D.23103;
  int D.23104;
  _Bool D.23109;
  long int D.23110;
  long int D.23111;
  unsigned int D.23114;
  unsigned int D.23115;
  struct MonoClass * D.23118;
  int D.23120;
  int D.23121;
  struct MonoPerfCounters * mono_perfcounters.72;
  unsigned int D.23123;
  unsigned int D.23124;
  unsigned int D.23125;
  _Bool D.23128;
  long int D.23129;
  long int D.23130;
  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.23084 = &domain->lock.mutex;
        ret = pthread_mutex_lock (D.23084);
        if (ret != 0) goto <D.23085>; else goto <D.23086>;
        <D.23085>:
        monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
        <D.23086>:
        D.23087 = ret != 0;
        D.23088 = (long int) D.23087;
        D.23089 = __builtin_expect (D.23088, 0);
        if (D.23089 != 0) goto <D.23090>; else goto <D.23091>;
        <D.23090>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 2515, "ret == 0");
        <D.23091>:
      }
      D.23092 = domain->proxy_vtable_hash;
      rc = monoeg_g_hash_table_lookup (D.23092, key);
      if (rc != 0B) goto <D.23093>; else goto <D.23094>;
      <D.23093>:
      monoeg_g_free (key);
      {
        int ret;

        D.23084 = &domain->lock.mutex;
        ret = pthread_mutex_unlock (D.23084);
        if (ret != 0) goto <D.23095>; else goto <D.23096>;
        <D.23095>:
        monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
        <D.23096>:
        D.23097 = ret != 0;
        D.23098 = (long int) D.23097;
        D.23099 = __builtin_expect (D.23098, 0);
        if (D.23099 != 0) goto <D.23100>; else goto <D.23101>;
        <D.23100>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 2520, "ret == 0");
        <D.23101>:
      }
      D.23102 = rc;
      return D.23102;
      <D.23094>:
      D.23103 = domain->mp;
      name = mono_string_to_utf8_mp (D.23103, class_name, &error);
      D.23104 = mono_error_ok (&error);
      if (D.23104 == 0) goto <D.23105>; else goto <D.23106>;
      <D.23105>:
      monoeg_g_free (key);
      {
        int ret;

        D.23084 = &domain->lock.mutex;
        ret = pthread_mutex_unlock (D.23084);
        if (ret != 0) goto <D.23107>; else goto <D.23108>;
        <D.23107>:
        monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
        <D.23108>:
        D.23109 = ret != 0;
        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", 2527, "ret == 0");
        <D.23113>:
      }
      mono_error_raise_exception (&error);
      <D.23106>:
      mp_key = copy_remote_class_key (domain, key);
      monoeg_g_free (key);
      key = mp_key;
      D.23114 = proxy_class->flags;
      D.23115 = D.23114 & 32;
      if (D.23115 != 0) goto <D.23116>; else goto <D.23117>;
      <D.23116>:
      rc = mono_domain_alloc (domain, 48);
      rc->interface_count = 1;
      rc->interfaces[0] = proxy_class;
      D.23118 = mono_defaults.marshalbyrefobject_class;
      rc->proxy_class = D.23118;
      goto <D.23119>;
      <D.23117>:
      rc = mono_domain_alloc (domain, 40);
      rc->interface_count = 0;
      rc->proxy_class = proxy_class;
      <D.23119>:
      rc->default_vtable = 0B;
      rc->xdomain_vtable = 0B;
      rc->proxy_class_name = name;
      D.23120 = mono_string_length (class_name);
      D.23121 = D.23120 + 1;
      mono_perfcounters.72 = mono_perfcounters;
      mono_perfcounters.72 = mono_perfcounters;
      D.23123 = mono_perfcounters.72->loader_bytes;
      D.23124 = (unsigned int) D.23121;
      D.23125 = D.23123 + D.23124;
      mono_perfcounters.72->loader_bytes = D.23125;
      D.23092 = domain->proxy_vtable_hash;
      monoeg_g_hash_table_insert_replace (D.23092, key, rc, 0);
      {
        int ret;

        D.23084 = &domain->lock.mutex;
        ret = pthread_mutex_unlock (D.23084);
        if (ret != 0) goto <D.23126>; else goto <D.23127>;
        <D.23126>:
        monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
        <D.23127>:
        D.23128 = ret != 0;
        D.23129 = (long int) D.23128;
        D.23130 = __builtin_expect (D.23129, 0);
        if (D.23130 != 0) goto <D.23131>; else goto <D.23132>;
        <D.23131>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 2555, "ret == 0");
        <D.23132>:
      }
      D.23102 = rc;
      return D.23102;
    }
  finally
    {
      error = {CLOBBER};
    }
}


create_remote_class_key (struct MonoRemoteClass * remote_class, struct MonoClass * extra_class)
{
  unsigned int D.23137;
  unsigned int D.23138;
  void * * D.23141;
  struct MonoClass * D.23142;
  void * * D.23143;
  unsigned int D.23149;
  unsigned int D.23150;
  long unsigned int D.23151;
  long unsigned int D.23152;
  unsigned int D.23153;
  long int D.23154;
  void * D.23155;
  struct MonoClass * D.23156;
  struct MonoClass * D.23159;
  int j.73;
  long unsigned int D.23163;
  long unsigned int D.23164;
  void * * D.23165;
  long unsigned int D.23166;
  long unsigned int D.23167;
  void * * D.23168;
  unsigned int i.74;
  long unsigned int D.23172;
  long unsigned int D.23173;
  unsigned int D.23174;
  long int D.23175;
  void * D.23176;
  struct MonoClass * iftmp.75;
  int D.23181;
  long unsigned int D.23182;
  long unsigned int D.23183;
  void * * D.23184;
  void * * D.23185;
  void * * key;
  int i;
  int j;

  if (remote_class == 0B) goto <D.23135>; else goto <D.23136>;
  <D.23135>:
  D.23137 = extra_class->flags;
  D.23138 = D.23137 & 32;
  if (D.23138 != 0) goto <D.23139>; else goto <D.23140>;
  <D.23139>:
  key = monoeg_malloc (24);
  *key = 2B;
  D.23141 = key + 8;
  D.23142 = mono_defaults.marshalbyrefobject_class;
  *D.23141 = D.23142;
  D.23143 = key + 16;
  *D.23143 = extra_class;
  goto <D.23144>;
  <D.23140>:
  key = monoeg_malloc (16);
  *key = 1B;
  D.23141 = key + 8;
  *D.23141 = extra_class;
  <D.23144>:
  goto <D.23145>;
  <D.23136>:
  if (extra_class != 0B) goto <D.23147>; else goto <D.23146>;
  <D.23147>:
  D.23137 = extra_class->flags;
  D.23138 = D.23137 & 32;
  if (D.23138 != 0) goto <D.23148>; else goto <D.23146>;
  <D.23148>:
  D.23149 = remote_class->interface_count;
  D.23150 = D.23149 + 3;
  D.23151 = (long unsigned int) D.23150;
  D.23152 = D.23151 * 8;
  key = monoeg_malloc (D.23152);
  D.23149 = remote_class->interface_count;
  D.23153 = D.23149 + 2;
  D.23154 = (long int) D.23153;
  D.23155 = (void *) D.23154;
  *key = D.23155;
  D.23141 = key + 8;
  D.23156 = remote_class->proxy_class;
  *D.23141 = D.23156;
  i = 0;
  j = 2;
  goto <D.20194>;
  <D.20193>:
  if (extra_class != 0B) goto <D.23157>; else goto <D.23158>;
  <D.23157>:
  D.23159 = remote_class->interfaces[i];
  if (D.23159 > extra_class) goto <D.23160>; else goto <D.23161>;
  <D.23160>:
  j.73 = j;
  j = j.73 + 1;
  D.23163 = (long unsigned int) j.73;
  D.23164 = D.23163 * 8;
  D.23165 = key + D.23164;
  *D.23165 = extra_class;
  extra_class = 0B;
  <D.23161>:
  <D.23158>:
  D.23166 = (long unsigned int) j;
  D.23167 = D.23166 * 8;
  D.23168 = key + D.23167;
  D.23159 = remote_class->interfaces[i];
  *D.23168 = D.23159;
  i = i + 1;
  j = j + 1;
  <D.20194>:
  i.74 = (unsigned int) i;
  D.23149 = remote_class->interface_count;
  if (i.74 < D.23149) goto <D.20193>; else goto <D.20195>;
  <D.20195>:
  if (extra_class != 0B) goto <D.23170>; else goto <D.23171>;
  <D.23170>:
  D.23166 = (long unsigned int) j;
  D.23167 = D.23166 * 8;
  D.23168 = key + D.23167;
  *D.23168 = extra_class;
  <D.23171>:
  goto <D.20198>;
  <D.23146>:
  D.23149 = remote_class->interface_count;
  D.23153 = D.23149 + 2;
  D.23172 = (long unsigned int) D.23153;
  D.23173 = D.23172 * 8;
  key = monoeg_malloc (D.23173);
  D.23149 = remote_class->interface_count;
  D.23174 = D.23149 + 1;
  D.23175 = (long int) D.23174;
  D.23176 = (void *) D.23175;
  *key = D.23176;
  D.23141 = key + 8;
  if (extra_class == 0B) goto <D.23178>; else goto <D.23179>;
  <D.23178>:
  iftmp.75 = remote_class->proxy_class;
  goto <D.23180>;
  <D.23179>:
  iftmp.75 = extra_class;
  <D.23180>:
  *D.23141 = iftmp.75;
  i = 0;
  goto <D.20197>;
  <D.20196>:
  D.23181 = i + 2;
  D.23182 = (long unsigned int) D.23181;
  D.23183 = D.23182 * 8;
  D.23184 = key + D.23183;
  D.23159 = remote_class->interfaces[i];
  *D.23184 = D.23159;
  i = i + 1;
  <D.20197>:
  i.74 = (unsigned int) i;
  D.23149 = remote_class->interface_count;
  if (i.74 < D.23149) goto <D.20196>; else goto <D.20198>;
  <D.20198>:
  <D.23145>:
  D.23185 = key;
  return D.23185;
}


copy_remote_class_key (struct MonoDomain * domain, void * * key)
{
  void * D.23187;
  long int D.23188;
  unsigned int D.23189;
  unsigned int D.23190;
  unsigned int D.23191;
  unsigned int key_size.76;
  long unsigned int D.23193;
  void * * D.23194;
  int key_size;
  void * * mp_key;

  D.23187 = *key;
  D.23188 = (long int) D.23187;
  D.23189 = (unsigned int) D.23188;
  D.23190 = D.23189 + 1;
  D.23191 = D.23190 * 8;
  key_size = (int) D.23191;
  key_size.76 = (unsigned int) key_size;
  mp_key = mono_domain_alloc (domain, key_size.76);
  D.23193 = (long unsigned int) key_size;
  memcpy (mp_key, key, D.23193);
  D.23194 = mp_key;
  return D.23194;
}


mono_remote_class_vtable (struct MonoDomain * domain, struct MonoRemoteClass * remote_class, struct MonoRealProxy * rp)
{
  union mono_mutex_t * D.23196;
  _Bool D.23199;
  long int D.23200;
  long int D.23201;
  int D.23204;
  struct MonoVTable * D.23207;
  struct MonoVTable * D.23210;
  _Bool D.23213;
  long int D.23214;
  long int D.23215;
  void * D.23218;
  struct MonoVTable * D.23219;
  struct MonoReflectionType * D.23222;
  long unsigned int D.23226;
  long unsigned int D.23227;
  struct MonoClass * D.23229;
  struct MonoClass * D.23231;
  struct MonoDomain * D.23232;
  struct MonoVTable * D.23233;
  long unsigned int D.23234;
  long unsigned int D.23235;
  struct MonoVTable * D.23237;
  struct MonoVTable * D.23238;
  _Bool D.23241;
  long int D.23242;
  long int D.23243;

  mono_loader_lock ();
  {
    int ret;

    D.23196 = &domain->lock.mutex;
    ret = pthread_mutex_lock (D.23196);
    if (ret != 0) goto <D.23197>; else goto <D.23198>;
    <D.23197>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
    <D.23198>:
    D.23199 = ret != 0;
    D.23200 = (long int) D.23199;
    D.23201 = __builtin_expect (D.23200, 0);
    if (D.23201 != 0) goto <D.23202>; else goto <D.23203>;
    <D.23202>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 2617, "ret == 0");
    <D.23203>:
  }
  D.23204 = rp->target_domain_id;
  if (D.23204 != -1) goto <D.23205>; else goto <D.23206>;
  <D.23205>:
  D.23207 = remote_class->xdomain_vtable;
  if (D.23207 == 0B) goto <D.23208>; else goto <D.23209>;
  <D.23208>:
  D.23210 = mono_class_proxy_vtable (domain, remote_class, 1);
  remote_class->xdomain_vtable = D.23210;
  <D.23209>:
  {
    int ret;

    D.23196 = &domain->lock.mutex;
    ret = pthread_mutex_unlock (D.23196);
    if (ret != 0) goto <D.23211>; else goto <D.23212>;
    <D.23211>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.23212>:
    D.23213 = ret != 0;
    D.23214 = (long int) D.23213;
    D.23215 = __builtin_expect (D.23214, 0);
    if (D.23215 != 0) goto <D.23216>; else goto <D.23217>;
    <D.23216>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 2621, "ret == 0");
    <D.23217>:
  }
  mono_loader_unlock ();
  D.23218 = remote_class->xdomain_vtable;
  return D.23218;
  <D.23206>:
  D.23219 = remote_class->default_vtable;
  if (D.23219 == 0B) goto <D.23220>; else goto <D.23221>;
  <D.23220>:
  {
    struct MonoType * type;
    struct MonoClass * klass;

    D.23222 = rp->class_to_proxy;
    type = D.23222->type;
    klass = mono_class_from_mono_type (type);
    D.23226 = BIT_FIELD_REF <*klass, 64, 256>;
    D.23227 = D.23226 & 1073741824;
    if (D.23227 != 0) goto <D.23223>; else goto <D.23228>;
    <D.23228>:
    D.23229 = mono_class_get_com_object_class ();
    if (D.23229 != 0B) goto <D.23230>; else goto <D.23224>;
    <D.23230>:
    D.23231 = mono_class_get_com_object_class ();
    if (D.23231 == klass) goto <D.23223>; else goto <D.23224>;
    <D.23223>:
    D.23232 = mono_domain_get ();
    D.23233 = mono_class_vtable (D.23232, klass);
    D.23234 = BIT_FIELD_REF <*D.23233, 64, 320>;
    D.23235 = D.23234 & 16777216;
    if (D.23235 == 0) goto <D.23236>; else goto <D.23224>;
    <D.23236>:
    D.23237 = mono_class_proxy_vtable (domain, remote_class, 2);
    remote_class->default_vtable = D.23237;
    goto <D.23225>;
    <D.23224>:
    D.23238 = mono_class_proxy_vtable (domain, remote_class, 0);
    remote_class->default_vtable = D.23238;
    <D.23225>:
  }
  <D.23221>:
  {
    int ret;

    D.23196 = &domain->lock.mutex;
    ret = pthread_mutex_unlock (D.23196);
    if (ret != 0) goto <D.23239>; else goto <D.23240>;
    <D.23239>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.23240>:
    D.23241 = ret != 0;
    D.23242 = (long int) D.23241;
    D.23243 = __builtin_expect (D.23242, 0);
    if (D.23243 != 0) goto <D.23244>; else goto <D.23245>;
    <D.23244>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 2638, "ret == 0");
    <D.23245>:
  }
  mono_loader_unlock ();
  D.23218 = remote_class->default_vtable;
  return D.23218;
}


mono_class_proxy_vtable (struct MonoDomain * domain, struct MonoRemoteClass * remote_class, MonoRemotingTarget target_type)
{
  _Bool D.23247;
  long int D.23248;
  long int D.23249;
  short unsigned int D.23252;
  short unsigned int D.23253;
  short unsigned int D.23254;
  guint8 * D.23257;
  short unsigned int D.23258;
  sizetype D.23259;
  guint8 * D.23260;
  unsigned char D.23261;
  int D.23262;
  int D.23263;
  int D.23264;
  int D.23265;
  int D.23266;
  struct GSList * D.23269;
  int D.23272;
  _Bool D.23273;
  long int D.23274;
  long int D.23275;
  void * * D.23280;
  long unsigned int D.23281;
  long unsigned int D.23282;
  void * * D.23283;
  short unsigned int D.23284;
  short unsigned int D.23287;
  sizetype D.23288;
  guint8 * D.23289;
  unsigned char D.23290;
  int D.23291;
  int D.23292;
  int D.23293;
  int D.23294;
  int D.23295;
  struct GSList * D.23298;
  int D.23301;
  unsigned int i.77;
  unsigned int D.23303;
  long unsigned int D.23304;
  unsigned int D.23305;
  unsigned int D.23306;
  unsigned int extra_interface_vtsize.78;
  unsigned int D.23308;
  short unsigned int D.23309;
  int D.23310;
  unsigned int j.79;
  unsigned int D.23314;
  void * (*<T2810>) (struct MonoVTable *, struct MonoDomain *, struct MonoIMTCheckItem * *, int, void *) imt_thunk_builder.80;
  long unsigned int D.23318;
  long unsigned int D.23319;
  long unsigned int D.23320;
  long unsigned int D.23321;
  int D.23322;
  long unsigned int D.23323;
  long unsigned int D.23324;
  unsigned int D.23325;
  unsigned int D.23326;
  int D.23328;
  long unsigned int D.23329;
  long unsigned int D.23330;
  long unsigned int D.23331;
  unsigned int D.23332;
  unsigned int D.23333;
  long unsigned int D.23334;
  int D.23335;
  long unsigned int D.23336;
  long unsigned int D.23337;
  unsigned int D.23338;
  sizetype D.23342;
  sizetype D.23343;
  sizetype D.23344;
  long unsigned int D.23345;
  long unsigned int D.23346;
  struct MonoClass * D.23347;
  void * D.23348;
  struct MonoMethod * * D.23349;
  struct MonoMethod * * D.23350;
  void * (*<T1e5b>) (struct MonoDomain *, struct MonoMethod *, MonoRemotingTarget) arch_create_remoting_trampoline.81;
  void * D.23354;
  unsigned int D.23356;
  unsigned int D.23357;
  short int D.23360;
  int D.23361;
  void * D.23362;
  void * D.23365;
  short unsigned int D.23366;
  int D.23367;
  unsigned int bsize.82;
  struct MonoClass * * D.23371;
  struct MonoClass * * D.23372;
  struct MonoClass * D.23373;
  short unsigned int D.23374;
  guint16 * D.23375;
  long unsigned int D.23376;
  guint16 * D.23377;
  short unsigned int D.23378;
  int D.23379;
  int D.23380;
  long unsigned int D.23381;
  long unsigned int D.23382;
  void * * D.23383;
  void * * D.23384;
  short unsigned int D.23385;
  int D.23386;
  int D.23387;
  sizetype D.23388;
  uint8_t * D.23389;
  unsigned char D.23390;
  signed char D.23391;
  int D.23392;
  int D.23393;
  signed char D.23394;
  signed char D.23395;
  unsigned char D.23396;
  short unsigned int D.23401;
  int D.23402;
  int D.23403;
  long unsigned int D.23404;
  long unsigned int D.23405;
  void * * D.23406;
  void * * D.23407;
  short unsigned int D.23408;
  sizetype D.23409;
  uint8_t * D.23410;
  unsigned char D.23411;
  signed char D.23412;
  int D.23413;
  int D.23414;
  signed char D.23415;
  signed char D.23416;
  unsigned char D.23417;
  int j.83;
  int D.23419;
  void * D.23420;
  int D.23421;
  struct MonoVTable * D.23428;
  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.23247 = vt == 0B;
      D.23248 = (long int) D.23247;
      D.23249 = __builtin_expect (D.23248, 0);
      if (D.23249 != 0) goto <D.23250>; else goto <D.23251>;
      <D.23250>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 2215, "vt");
      <D.23251>:
      D.23252 = vt->max_interface_id;
      max_interface_id = (int) D.23252;
      j = 0;
      goto <D.20120>;
      <D.20119>:
      {
        struct MonoClass * iclass;
        struct GPtrArray * ifaces;
        int method_count;

        iclass = remote_class->interfaces[j];
        D.23253 = iclass->interface_id;
        D.23254 = class->max_interface_id;
        if (D.23253 <= D.23254) goto <D.23255>; else goto <D.23256>;
        <D.23255>:
        D.23257 = class->interface_bitmap;
        D.23253 = iclass->interface_id;
        D.23258 = D.23253 >> 3;
        D.23259 = (sizetype) D.23258;
        D.23260 = D.23257 + D.23259;
        D.23261 = *D.23260;
        D.23262 = (int) D.23261;
        D.23253 = iclass->interface_id;
        D.23263 = (int) D.23253;
        D.23264 = D.23263 & 7;
        D.23265 = D.23262 >> D.23264;
        D.23266 = D.23265 & 1;
        if (D.23266 != 0) goto <D.23267>; else goto <D.23268>;
        <D.23267>:
        // predicted unlikely by continue predictor.
        goto <D.20113>;
        <D.23268>:
        <D.23256>:
        D.23269 = monoeg_g_slist_find (extra_interfaces, iclass);
        if (D.23269 != 0B) goto <D.23270>; else goto <D.23271>;
        <D.23270>:
        // predicted unlikely by continue predictor.
        goto <D.20113>;
        <D.23271>:
        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.23272 = mono_error_ok (&error);
        D.23273 = D.23272 == 0;
        D.23274 = (long int) D.23273;
        D.23275 = __builtin_expect (D.23274, 0);
        if (D.23275 != 0) goto <D.23276>; else goto <D.23277>;
        <D.23276>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 2235, "mono_error_ok (&error)");
        <D.23277>:
        if (ifaces != 0B) goto <D.23278>; else goto <D.23279>;
        <D.23278>:
        i = 0;
        goto <D.20117>;
        <D.20116>:
        {
          struct MonoClass * ic;

          D.23280 = ifaces->pdata;
          D.23281 = (long unsigned int) i;
          D.23282 = D.23281 * 8;
          D.23283 = D.23280 + D.23282;
          ic = *D.23283;
          D.23284 = ic->interface_id;
          D.23254 = class->max_interface_id;
          if (D.23284 <= D.23254) goto <D.23285>; else goto <D.23286>;
          <D.23285>:
          D.23257 = class->interface_bitmap;
          D.23284 = ic->interface_id;
          D.23287 = D.23284 >> 3;
          D.23288 = (sizetype) D.23287;
          D.23289 = D.23257 + D.23288;
          D.23290 = *D.23289;
          D.23291 = (int) D.23290;
          D.23284 = ic->interface_id;
          D.23292 = (int) D.23284;
          D.23293 = D.23292 & 7;
          D.23294 = D.23291 >> D.23293;
          D.23295 = D.23294 & 1;
          if (D.23295 != 0) goto <D.23296>; else goto <D.23297>;
          <D.23296>:
          // predicted unlikely by continue predictor.
          goto <D.20115>;
          <D.23297>:
          <D.23286>:
          D.23298 = monoeg_g_slist_find (extra_interfaces, ic);
          if (D.23298 != 0B) goto <D.23299>; else goto <D.23300>;
          <D.23299>:
          // predicted unlikely by continue predictor.
          goto <D.20115>;
          <D.23300>:
          extra_interfaces = monoeg_g_slist_prepend (extra_interfaces, ic);
          D.23301 = mono_class_num_methods (ic);
          method_count = D.23301 + method_count;
        }
        <D.20115>:
        i = i + 1;
        <D.20117>:
        i.77 = (unsigned int) i;
        D.23303 = ifaces->len;
        if (i.77 < D.23303) goto <D.20116>; else goto <D.20118>;
        <D.20118>:
        monoeg_g_ptr_array_free (ifaces, 1);
        <D.23279>:
        D.23304 = (long unsigned int) method_count;
        D.23305 = (unsigned int) D.23304;
        D.23306 = D.23305 * 8;
        extra_interface_vtsize.78 = (unsigned int) extra_interface_vtsize;
        D.23308 = D.23306 + extra_interface_vtsize.78;
        extra_interface_vtsize = (int) D.23308;
        D.23309 = iclass->max_interface_id;
        D.23310 = (int) D.23309;
        if (D.23310 > max_interface_id) goto <D.23311>; else goto <D.23312>;
        <D.23311>:
        D.23309 = iclass->max_interface_id;
        max_interface_id = (int) D.23309;
        <D.23312>:
      }
      <D.20113>:
      j = j + 1;
      <D.20120>:
      j.79 = (unsigned int) j;
      D.23314 = remote_class->interface_count;
      if (j.79 < D.23314) goto <D.20119>; else goto <D.20121>;
      <D.20121>:
      imt_thunk_builder.80 = imt_thunk_builder;
      if (imt_thunk_builder.80 != 0B) goto <D.23316>; else goto <D.23317>;
      <D.23316>:
      D.23318 = mono_stats.imt_number_of_tables;
      D.23319 = D.23318 + 1;
      mono_stats.imt_number_of_tables = D.23319;
      D.23320 = mono_stats.imt_tables_size;
      D.23321 = D.23320 + 152;
      mono_stats.imt_tables_size = D.23321;
      D.23322 = class->vtable_size;
      D.23323 = (long unsigned int) D.23322;
      D.23324 = D.23323 + 26;
      D.23325 = (unsigned int) D.23324;
      D.23326 = D.23325 * 8;
      vtsize = (int) D.23326;
      goto <D.23327>;
      <D.23317>:
      D.23328 = max_interface_id + 1;
      D.23329 = (long unsigned int) D.23328;
      D.23322 = class->vtable_size;
      D.23323 = (long unsigned int) D.23322;
      D.23330 = D.23329 + D.23323;
      D.23331 = D.23330 + 7;
      D.23332 = (unsigned int) D.23331;
      D.23333 = D.23332 * 8;
      vtsize = (int) D.23333;
      <D.23327>:
      D.23334 = mono_stats.class_vtable_size;
      D.23335 = vtsize + extra_interface_vtsize;
      D.23336 = (long unsigned int) D.23335;
      D.23337 = D.23334 + D.23336;
      mono_stats.class_vtable_size = D.23337;
      D.23335 = vtsize + extra_interface_vtsize;
      D.23338 = (unsigned int) D.23335;
      interface_offsets = mono_domain_alloc0 (domain, D.23338);
      imt_thunk_builder.80 = imt_thunk_builder;
      if (imt_thunk_builder.80 != 0B) goto <D.23339>; else goto <D.23340>;
      <D.23339>:
      pvt = interface_offsets + 152;
      goto <D.23341>;
      <D.23340>:
      D.23342 = (sizetype) max_interface_id;
      D.23343 = D.23342 + 1;
      D.23344 = D.23343 * 8;
      pvt = interface_offsets + D.23344;
      <D.23341>:
      D.23322 = class->vtable_size;
      D.23323 = (long unsigned int) D.23322;
      D.23345 = D.23323 + 7;
      D.23346 = D.23345 * 8;
      memcpy (pvt, vt, D.23346);
      D.23347 = mono_defaults.transparent_proxy_class;
      pvt->klass = D.23347;
      D.23347 = mono_defaults.transparent_proxy_class;
      D.23348 = D.23347->gc_descr;
      pvt->gc_descr = D.23348;
      mono_class_setup_vtable (class);
      i = 0;
      goto <D.20124>;
      <D.20123>:
      {
        struct MonoMethod * cm;

        D.23349 = class->vtable;
        D.23281 = (long unsigned int) i;
        D.23282 = D.23281 * 8;
        D.23350 = D.23349 + D.23282;
        cm = *D.23350;
        if (cm != 0B) goto <D.23351>; else goto <D.23352>;
        <D.23351>:
        arch_create_remoting_trampoline.81 = arch_create_remoting_trampoline;
        D.23354 = arch_create_remoting_trampoline.81 (domain, cm, target_type);
        pvt->vtable[i] = D.23354;
        goto <D.23355>;
        <D.23352>:
        pvt->vtable[i] = 0B;
        <D.23355>:
      }
      i = i + 1;
      <D.20124>:
      D.23322 = class->vtable_size;
      if (D.23322 > i) goto <D.20123>; else goto <D.20125>;
      <D.20125>:
      D.23356 = class->flags;
      D.23357 = D.23356 & 128;
      if (D.23357 != 0) goto <D.23358>; else goto <D.23359>;
      <D.23358>:
      k = class;
      goto <D.20132>;
      <D.20131>:
      {
        struct MonoMethod * m;
        void * iter;

        try
          {
            iter = 0B;
            goto <D.20129>;
            <D.20128>:
            D.23360 = m->slot;
            D.23361 = (int) D.23360;
            D.23362 = pvt->vtable[D.23361];
            if (D.23362 == 0B) goto <D.23363>; else goto <D.23364>;
            <D.23363>:
            D.23360 = m->slot;
            D.23361 = (int) D.23360;
            arch_create_remoting_trampoline.81 = arch_create_remoting_trampoline;
            D.23365 = arch_create_remoting_trampoline.81 (domain, m, target_type);
            pvt->vtable[D.23361] = D.23365;
            <D.23364>:
            <D.20129>:
            m = mono_class_get_methods (k, &iter);
            if (m != 0B) goto <D.20128>; else goto <D.20130>;
            <D.20130>:
          }
        finally
          {
            iter = {CLOBBER};
          }
      }
      k = k->parent;
      <D.20132>:
      if (k != 0B) goto <D.20131>; else goto <D.20133>;
      <D.20133>:
      <D.23359>:
      D.23366 = (short unsigned int) max_interface_id;
      pvt->max_interface_id = D.23366;
      D.23367 = max_interface_id / 8;
      bsize = D.23367 + 1;
      bsize.82 = (unsigned int) bsize;
      bitmap = mono_domain_alloc0 (domain, bsize.82);
      imt_thunk_builder.80 = imt_thunk_builder;
      if (imt_thunk_builder.80 == 0B) goto <D.23369>; else goto <D.23370>;
      <D.23369>:
      i = 0;
      goto <D.20137>;
      <D.20136>:
      {
        int interface_id;
        int slot;

        D.23371 = class->interfaces_packed;
        D.23281 = (long unsigned int) i;
        D.23282 = D.23281 * 8;
        D.23372 = D.23371 + D.23282;
        D.23373 = *D.23372;
        D.23374 = D.23373->interface_id;
        interface_id = (int) D.23374;
        D.23375 = class->interface_offsets_packed;
        D.23281 = (long unsigned int) i;
        D.23376 = D.23281 * 2;
        D.23377 = D.23375 + D.23376;
        D.23378 = *D.23377;
        slot = (int) D.23378;
        D.23254 = class->max_interface_id;
        D.23379 = (int) D.23254;
        D.23380 = D.23379 - interface_id;
        D.23381 = (long unsigned int) D.23380;
        D.23382 = D.23381 * 8;
        D.23383 = interface_offsets + D.23382;
        D.23384 = &pvt->vtable[slot];
        *D.23383 = D.23384;
      }
      i = i + 1;
      <D.20137>:
      D.23385 = class->interface_offsets_count;
      D.23386 = (int) D.23385;
      if (D.23386 > i) goto <D.20136>; else goto <D.20138>;
      <D.20138>:
      <D.23370>:
      i = 0;
      goto <D.20141>;
      <D.20140>:
      {
        int interface_id;

        D.23371 = class->interfaces_packed;
        D.23281 = (long unsigned int) i;
        D.23282 = D.23281 * 8;
        D.23372 = D.23371 + D.23282;
        D.23373 = *D.23372;
        D.23374 = D.23373->interface_id;
        interface_id = (int) D.23374;
        D.23387 = interface_id >> 3;
        D.23388 = (sizetype) D.23387;
        D.23389 = bitmap + D.23388;
        D.23387 = interface_id >> 3;
        D.23388 = (sizetype) D.23387;
        D.23389 = bitmap + D.23388;
        D.23390 = *D.23389;
        D.23391 = (signed char) D.23390;
        D.23392 = interface_id & 7;
        D.23393 = 1 << D.23392;
        D.23394 = (signed char) D.23393;
        D.23395 = D.23391 | D.23394;
        D.23396 = (unsigned char) D.23395;
        *D.23389 = D.23396;
      }
      i = i + 1;
      <D.20141>:
      D.23385 = class->interface_offsets_count;
      D.23386 = (int) D.23385;
      if (D.23386 > i) goto <D.20140>; else goto <D.20142>;
      <D.20142>:
      if (extra_interfaces != 0B) goto <D.23397>; else goto <D.23398>;
      <D.23397>:
      {
        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.20152>;
            <D.20151>:
            interf = list_item->data;
            imt_thunk_builder.80 = imt_thunk_builder;
            if (imt_thunk_builder.80 == 0B) goto <D.23399>; else goto <D.23400>;
            <D.23399>:
            D.23401 = interf->interface_id;
            D.23402 = (int) D.23401;
            D.23403 = max_interface_id - D.23402;
            D.23404 = (long unsigned int) D.23403;
            D.23405 = D.23404 * 8;
            D.23406 = interface_offsets + D.23405;
            D.23407 = &pvt->vtable[slot];
            *D.23406 = D.23407;
            <D.23400>:
            D.23401 = interf->interface_id;
            D.23408 = D.23401 >> 3;
            D.23409 = (sizetype) D.23408;
            D.23410 = bitmap + D.23409;
            D.23401 = interf->interface_id;
            D.23408 = D.23401 >> 3;
            D.23409 = (sizetype) D.23408;
            D.23410 = bitmap + D.23409;
            D.23411 = *D.23410;
            D.23412 = (signed char) D.23411;
            D.23401 = interf->interface_id;
            D.23402 = (int) D.23401;
            D.23413 = D.23402 & 7;
            D.23414 = 1 << D.23413;
            D.23415 = (signed char) D.23414;
            D.23416 = D.23412 | D.23415;
            D.23417 = (unsigned char) D.23416;
            *D.23410 = D.23417;
            iter = 0B;
            j = 0;
            goto <D.20149>;
            <D.20148>:
            j.83 = j;
            j = j.83 + 1;
            D.23419 = j.83 + slot;
            arch_create_remoting_trampoline.81 = arch_create_remoting_trampoline;
            D.23420 = arch_create_remoting_trampoline.81 (domain, cm, target_type);
            pvt->vtable[D.23419] = D.23420;
            <D.20149>:
            cm = mono_class_get_methods (interf, &iter);
            if (cm != 0B) goto <D.20148>; else goto <D.20150>;
            <D.20150>:
            D.23421 = mono_class_num_methods (interf);
            slot = D.23421 + slot;
            list_item = list_item->next;
            <D.20152>:
            if (list_item != 0B) goto <D.20151>; else goto <D.20153>;
            <D.20153>:
            imt_thunk_builder.80 = imt_thunk_builder;
            if (imt_thunk_builder.80 == 0B) goto <D.23422>; else goto <D.23423>;
            <D.23422>:
            monoeg_g_slist_free (extra_interfaces);
            <D.23423>:
          }
        finally
          {
            iter = {CLOBBER};
          }
      }
      <D.23398>:
      imt_thunk_builder.80 = imt_thunk_builder;
      if (imt_thunk_builder.80 != 0B) goto <D.23424>; else goto <D.23425>;
      <D.23424>:
      build_imt (class, pvt, domain, interface_offsets, extra_interfaces);
      if (extra_interfaces != 0B) goto <D.23426>; else goto <D.23427>;
      <D.23426>:
      monoeg_g_slist_free (extra_interfaces);
      <D.23427>:
      <D.23425>:
      pvt->interface_bitmap = bitmap;
      D.23428 = pvt;
      return D.23428;
    }
  finally
    {
      error = {CLOBBER};
    }
}


mono_upgrade_remote_class (struct MonoDomain * domain, struct MonoObject * proxy_object, struct MonoClass * klass)
{
  union mono_mutex_t * D.23431;
  _Bool D.23434;
  long int D.23435;
  long int D.23436;
  unsigned int D.23439;
  unsigned int D.23440;
  struct MonoClass * D.23443;
  unsigned int i.84;
  unsigned int D.23447;
  struct MonoClass * D.23450;
  _Bool D.23451;
  struct MonoRemoteClass * D.23454;
  struct MonoRemoteClass * D.23455;
  struct MonoRealProxy * D.23456;
  void * D.23457;
  _Bool D.23460;
  long int D.23461;
  long int D.23462;
  struct MonoTransparentProxy * tproxy;
  struct MonoRemoteClass * remote_class;
  gboolean redo_vtable;

  mono_loader_lock ();
  {
    int ret;

    D.23431 = &domain->lock.mutex;
    ret = pthread_mutex_lock (D.23431);
    if (ret != 0) goto <D.23432>; else goto <D.23433>;
    <D.23432>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
    <D.23433>:
    D.23434 = ret != 0;
    D.23435 = (long int) D.23434;
    D.23436 = __builtin_expect (D.23435, 0);
    if (D.23436 != 0) goto <D.23437>; else goto <D.23438>;
    <D.23437>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 2661, "ret == 0");
    <D.23438>:
  }
  tproxy = proxy_object;
  remote_class = tproxy->remote_class;
  D.23439 = klass->flags;
  D.23440 = D.23439 & 32;
  if (D.23440 != 0) goto <D.23441>; else goto <D.23442>;
  <D.23441>:
  {
    int i;

    redo_vtable = 1;
    i = 0;
    goto <D.20253>;
    <D.20252>:
    D.23443 = remote_class->interfaces[i];
    if (D.23443 == klass) goto <D.23444>; else goto <D.23445>;
    <D.23444>:
    redo_vtable = 0;
    <D.23445>:
    i = i + 1;
    <D.20253>:
    i.84 = (unsigned int) i;
    D.23447 = remote_class->interface_count;
    if (i.84 < D.23447) goto <D.23448>; else goto <D.20254>;
    <D.23448>:
    if (redo_vtable != 0) goto <D.20252>; else goto <D.20254>;
    <D.20254>:
  }
  goto <D.23449>;
  <D.23442>:
  D.23450 = remote_class->proxy_class;
  D.23451 = D.23450 != klass;
  redo_vtable = (gboolean) D.23451;
  <D.23449>:
  if (redo_vtable != 0) goto <D.23452>; else goto <D.23453>;
  <D.23452>:
  D.23454 = clone_remote_class (domain, remote_class, klass);
  tproxy->remote_class = D.23454;
  D.23455 = tproxy->remote_class;
  D.23456 = tproxy->rp;
  D.23457 = mono_remote_class_vtable (domain, D.23455, D.23456);
  proxy_object->vtable = D.23457;
  <D.23453>:
  {
    int ret;

    D.23431 = &domain->lock.mutex;
    ret = pthread_mutex_unlock (D.23431);
    if (ret != 0) goto <D.23458>; else goto <D.23459>;
    <D.23458>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.23459>:
    D.23460 = ret != 0;
    D.23461 = (long int) D.23460;
    D.23462 = __builtin_expect (D.23461, 0);
    if (D.23462 != 0) goto <D.23463>; else goto <D.23464>;
    <D.23463>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 2682, "ret == 0");
    <D.23464>:
  }
  mono_loader_unlock ();
}


clone_remote_class (struct MonoDomain * domain, struct MonoRemoteClass * remote_class, struct MonoClass * extra_class)
{
  struct GHashTable * D.23465;
  struct MonoRemoteClass * D.23468;
  unsigned int D.23469;
  unsigned int D.23470;
  unsigned int D.23473;
  unsigned int D.23474;
  long unsigned int D.23475;
  long unsigned int D.23476;
  unsigned int D.23477;
  unsigned int D.23478;
  struct MonoClass * D.23479;
  struct MonoClass * D.23480;
  int j.85;
  unsigned int i.86;
  long unsigned int D.23490;
  long unsigned int D.23491;
  unsigned int D.23492;
  unsigned int D.23493;
  unsigned int D.23494;
  struct MonoClass *[0:] * D.23497;
  struct MonoClass *[0:] * D.23498;
  long unsigned int D.23499;
  long unsigned int D.23500;
  char * D.23501;
  struct MonoRemoteClass * rc;
  void * * key;
  void * * mp_key;

  key = create_remote_class_key (remote_class, extra_class);
  D.23465 = domain->proxy_vtable_hash;
  rc = monoeg_g_hash_table_lookup (D.23465, key);
  if (rc != 0B) goto <D.23466>; else goto <D.23467>;
  <D.23466>:
  monoeg_g_free (key);
  D.23468 = rc;
  return D.23468;
  <D.23467>:
  mp_key = copy_remote_class_key (domain, key);
  monoeg_g_free (key);
  key = mp_key;
  D.23469 = extra_class->flags;
  D.23470 = D.23469 & 32;
  if (D.23470 != 0) goto <D.23471>; else goto <D.23472>;
  <D.23471>:
  {
    int i;
    int j;

    D.23473 = remote_class->interface_count;
    D.23474 = D.23473 + 1;
    D.23475 = (long unsigned int) D.23474;
    D.23476 = D.23475 + 5;
    D.23477 = (unsigned int) D.23476;
    D.23478 = D.23477 * 8;
    rc = mono_domain_alloc (domain, D.23478);
    D.23479 = remote_class->proxy_class;
    rc->proxy_class = D.23479;
    D.23473 = remote_class->interface_count;
    D.23474 = D.23473 + 1;
    rc->interface_count = D.23474;
    i = 0;
    j = 0;
    goto <D.20230>;
    <D.20229>:
    D.23480 = remote_class->interfaces[i];
    if (D.23480 > extra_class) goto <D.23481>; else goto <D.23482>;
    <D.23481>:
    if (i == j) goto <D.23483>; else goto <D.23484>;
    <D.23483>:
    j.85 = j;
    j = j.85 + 1;
    rc->interfaces[j.85] = extra_class;
    <D.23484>:
    <D.23482>:
    D.23480 = remote_class->interfaces[i];
    rc->interfaces[j] = D.23480;
    i = i + 1;
    j = j + 1;
    <D.20230>:
    i.86 = (unsigned int) i;
    D.23473 = remote_class->interface_count;
    if (i.86 < D.23473) goto <D.20229>; else goto <D.20231>;
    <D.20231>:
    if (i == j) goto <D.23487>; else goto <D.23488>;
    <D.23487>:
    rc->interfaces[j] = extra_class;
    <D.23488>:
  }
  goto <D.23489>;
  <D.23472>:
  D.23473 = remote_class->interface_count;
  D.23490 = (long unsigned int) D.23473;
  D.23491 = D.23490 + 5;
  D.23492 = (unsigned int) D.23491;
  D.23493 = D.23492 * 8;
  rc = mono_domain_alloc (domain, D.23493);
  rc->proxy_class = extra_class;
  D.23473 = remote_class->interface_count;
  rc->interface_count = D.23473;
  D.23494 = rc->interface_count;
  if (D.23494 != 0) goto <D.23495>; else goto <D.23496>;
  <D.23495>:
  D.23497 = &rc->interfaces;
  D.23498 = &remote_class->interfaces;
  D.23494 = rc->interface_count;
  D.23499 = (long unsigned int) D.23494;
  D.23500 = D.23499 * 8;
  memcpy (D.23497, D.23498, D.23500);
  <D.23496>:
  <D.23489>:
  rc->default_vtable = 0B;
  rc->xdomain_vtable = 0B;
  D.23501 = remote_class->proxy_class_name;
  rc->proxy_class_name = D.23501;
  D.23465 = domain->proxy_vtable_hash;
  monoeg_g_hash_table_insert_replace (D.23465, key, rc, 0);
  D.23468 = rc;
  return D.23468;
}


mono_object_get_virtual_method (struct MonoObject * obj, struct MonoMethod * method)
{
  struct MonoVTable * D.23503;
  struct MonoClass * D.23504;
  struct MonoRemoteClass * D.23507;
  short unsigned int D.23510;
  unsigned int D.23511;
  unsigned int D.23512;
  struct MonoMethod * D.23515;
  short int D.23516;
  long unsigned int D.23519;
  long unsigned int D.23520;
  struct MonoMethod * D.23523;
  short int D.23524;
  _Bool D.23525;
  long int D.23526;
  long int D.23527;
  struct MonoClass * D.23535;
  unsigned int D.23536;
  unsigned int D.23537;
  _Bool D.23542;
  long int D.23543;
  long int D.23544;
  int D.23547;
  int D.23548;
  long unsigned int D.23549;
  long unsigned int D.23550;
  struct MonoMethod * * D.23551;
  long unsigned int D.23553;
  long unsigned int D.23554;
  struct MonoMethod * * D.23555;
  struct MonoMethodSignature * D.23561;
  short unsigned int D.23562;
  struct MonoMethodSignature * D.23563;
  short unsigned int D.23564;
  struct MonoClass * D.23571;
  long unsigned int D.23573;
  long unsigned int D.23574;
  struct MonoGenericContext * D.23578;
  _Bool D.23579;
  long int D.23580;
  long int D.23581;
  struct MonoClass * klass;
  struct MonoMethod * * vtable;
  gboolean is_proxy;
  struct MonoMethod * res;

  is_proxy = 0;
  res = 0B;
  D.23503 = obj->vtable;
  klass = D.23503->klass;
  D.23504 = mono_defaults.transparent_proxy_class;
  if (D.23504 == klass) goto <D.23505>; else goto <D.23506>;
  <D.23505>:
  D.23507 = MEM[(struct MonoTransparentProxy *)obj].remote_class;
  klass = D.23507->proxy_class;
  is_proxy = 1;
  <D.23506>:
  if (is_proxy == 0) goto <D.23508>; else goto <D.23509>;
  <D.23508>:
  D.23510 = method->flags;
  D.23511 = (unsigned int) D.23510;
  D.23512 = D.23511 & 96;
  if (D.23512 != 64) goto <D.23513>; else goto <D.23514>;
  <D.23513>:
  D.23515 = method;
  return D.23515;
  <D.23514>:
  <D.23509>:
  mono_class_setup_vtable (klass);
  vtable = klass->vtable;
  D.23516 = method->slot;
  if (D.23516 == -1) goto <D.23517>; else goto <D.23518>;
  <D.23517>:
  D.23519 = BIT_FIELD_REF <*method, 64, 256>;
  D.23520 = D.23519 & 4096;
  if (D.23520 != 0) goto <D.23521>; else goto <D.23522>;
  <D.23521>:
  D.23523 = MEM[(struct MonoMethodInflated *)method].declaring;
  D.23524 = D.23523->slot;
  D.23525 = D.23524 == -1;
  D.23526 = (long int) D.23525;
  D.23527 = __builtin_expect (D.23526, 0);
  if (D.23527 != 0) goto <D.23528>; else goto <D.23529>;
  <D.23528>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 2721, "((MonoMethodInflated*)method)->declaring->slot != -1");
  <D.23529>:
  D.23523 = MEM[(struct MonoMethodInflated *)method].declaring;
  D.23524 = D.23523->slot;
  method->slot = D.23524;
  goto <D.23530>;
  <D.23522>:
  if (is_proxy == 0) goto <D.23531>; else goto <D.23532>;
  <D.23531>:
  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "object.c", 2725);
  <D.23532>:
  <D.23530>:
  <D.23518>:
  D.23516 = method->slot;
  if (D.23516 != -1) goto <D.23533>; else goto <D.23534>;
  <D.23533>:
  D.23535 = method->klass;
  D.23536 = D.23535->flags;
  D.23537 = D.23536 & 32;
  if (D.23537 != 0) goto <D.23538>; else goto <D.23539>;
  <D.23538>:
  if (is_proxy == 0) goto <D.23540>; else goto <D.23541>;
  <D.23540>:
  {
    gboolean variance_used;
    int iface_offset;

    try
      {
        variance_used = 0;
        D.23535 = method->klass;
        iface_offset = mono_class_interface_offset_with_variance (klass, D.23535, &variance_used);
        D.23542 = iface_offset <= 0;
        D.23543 = (long int) D.23542;
        D.23544 = __builtin_expect (D.23543, 0);
        if (D.23544 != 0) goto <D.23545>; else goto <D.23546>;
        <D.23545>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 2735, "iface_offset > 0");
        <D.23546>:
        D.23516 = method->slot;
        D.23547 = (int) D.23516;
        D.23548 = D.23547 + iface_offset;
        D.23549 = (long unsigned int) D.23548;
        D.23550 = D.23549 * 8;
        D.23551 = vtable + D.23550;
        res = *D.23551;
      }
    finally
      {
        variance_used = {CLOBBER};
      }
  }
  <D.23541>:
  goto <D.23552>;
  <D.23539>:
  D.23516 = method->slot;
  D.23553 = (long unsigned int) D.23516;
  D.23554 = D.23553 * 8;
  D.23555 = vtable + D.23554;
  res = *D.23555;
  <D.23552>:
  <D.23534>:
  if (is_proxy != 0) goto <D.23556>; else goto <D.23557>;
  <D.23556>:
  if (res == 0B) goto <D.23558>; else goto <D.23560>;
  <D.23560>:
  D.23561 = mono_method_signature (res);
  D.23562 = D.23561->generic_param_count;
  if (D.23562 != 0) goto <D.23558>; else goto <D.23559>;
  <D.23558>:
  res = method;
  <D.23559>:
  D.23563 = mono_method_signature (res);
  D.23564 = D.23563->generic_param_count;
  if (D.23564 != 0) goto <D.23565>; else goto <D.23566>;
  <D.23565>:
  res = mono_marshal_get_remoting_invoke_with_check (res);
  goto <D.23567>;
  <D.23566>:
  D.23571 = mono_class_get_com_object_class ();
  if (D.23571 == klass) goto <D.23568>; else goto <D.23572>;
  <D.23572>:
  D.23573 = BIT_FIELD_REF <*klass, 64, 256>;
  D.23574 = D.23573 & 1073741824;
  if (D.23574 != 0) goto <D.23568>; else goto <D.23569>;
  <D.23568>:
  res = mono_cominterop_get_invoke (res);
  goto <D.23570>;
  <D.23569>:
  res = mono_marshal_get_remoting_invoke (res);
  <D.23570>:
  <D.23567>:
  goto <D.23575>;
  <D.23557>:
  D.23519 = BIT_FIELD_REF <*method, 64, 256>;
  D.23520 = D.23519 & 4096;
  if (D.23520 != 0) goto <D.23576>; else goto <D.23577>;
  <D.23576>:
  D.23578 = &MEM[(struct MonoMethodInflated *)method].context;
  res = mono_class_inflate_generic_method (res, D.23578);
  <D.23577>:
  <D.23575>:
  D.23579 = res == 0B;
  D.23580 = (long int) D.23579;
  D.23581 = __builtin_expect (D.23580, 0);
  if (D.23581 != 0) goto <D.23582>; else goto <D.23583>;
  <D.23582>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 2769, "res");
  <D.23583>:
  D.23515 = res;
  return D.23515;
}


mono_runtime_invoke (struct MonoMethod * method, void * obj, void * * params, struct MonoObject * * exc)
{
  int D.23585;
  char * D.23588;
  <unnamed type> D.23589;
  unsigned int D.23590;
  struct MonoObject * (*<T12ee>) (struct MonoMethod *, void *, void * *, struct MonoObject * *) default_mono_runtime_invoke.87;
  <unnamed type> D.23594;
  unsigned int D.23595;
  struct MonoObject * D.23598;
  struct MonoObject * result;

  D.23585 = mono_runtime_get_no_exec ();
  if (D.23585 != 0) goto <D.23586>; else goto <D.23587>;
  <D.23586>:
  D.23588 = mono_method_full_name (method, 1);
  monoeg_g_log (0B, 16, "Invoking method \'%s\' when running in no-exec mode.\n", D.23588);
  <D.23587>:
  D.23589 = mono_profiler_get_events ();
  D.23590 = D.23589 & 65536;
  if (D.23590 != 0) goto <D.23591>; else goto <D.23592>;
  <D.23591>:
  mono_profiler_method_start_invoke (method);
  <D.23592>:
  default_mono_runtime_invoke.87 = default_mono_runtime_invoke;
  result = default_mono_runtime_invoke.87 (method, obj, params, exc);
  D.23594 = mono_profiler_get_events ();
  D.23595 = D.23594 & 65536;
  if (D.23595 != 0) goto <D.23596>; else goto <D.23597>;
  <D.23596>:
  mono_profiler_method_end_invoke (method);
  <D.23597>:
  D.23598 = result;
  return D.23598;
}


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

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


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

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


mono_field_set_value (struct MonoObject * obj, struct MonoClassField * field, void * value)
{
  struct MonoType * D.23604;
  short unsigned int D.23605;
  int D.23606;
  int D.23607;
  int D.23610;
  sizetype D.23611;
  void * dest;

  D.23604 = field->type;
  D.23605 = D.23604->attrs;
  D.23606 = (int) D.23605;
  D.23607 = D.23606 & 16;
  if (D.23607 != 0) goto <D.23608>; else goto <D.23609>;
  <D.23608>:
  monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "object.c", 3003, "!(field->type->attrs & FIELD_ATTRIBUTE_STATIC)");
  return;
  <D.23609>:
  D.23610 = field->offset;
  D.23611 = (sizetype) D.23610;
  dest = obj + D.23611;
  D.23604 = field->type;
  set_value (D.23604, dest, value, 0);
}


set_value (struct MonoType * type, void * dest, void * value, int deref_pointer)
{
  long unsigned int D.23613;
  long unsigned int D.23614;
  unsigned char D.23617;
  guint8 iftmp.88;
  guint16 iftmp.89;
  int iftmp.90;
  gint64 iftmp.91;
  float iftmp.92;
  double iftmp.93;
  struct MonoObject * iftmp.94;
  void * iftmp.95;
  struct MonoClass * D.23652;
  long unsigned int D.23653;
  long unsigned int D.23654;
  struct MonoType * D.23656;
  unsigned char D.23657;
  long unsigned int D.23660;
  struct MonoGenericClass * D.23662;
  struct MonoClass * D.23663;
  unsigned char D.23664;
  int D.23665;
  int t;
  void handle_enum = <<< error >>>;

  D.23613 = BIT_FIELD_REF <*type, 64, 64>;
  D.23614 = D.23613 & 1073741824;
  if (D.23614 != 0) goto <D.23615>; else goto <D.23616>;
  <D.23615>:
  {
    void * * p;

    p = dest;
    *p = value;
    return;
  }
  <D.23616>:
  D.23617 = type->type;
  t = (int) D.23617;
  handle_enum:
  switch (t) <default: <D.20325>, case 2: <D.20293>, case 3: <D.20299>, case 4: <D.20294>, case 5: <D.20295>, case 6: <D.20297>, case 7: <D.20298>, case 8: <D.20301>, case 9: <D.20302>, case 10: <D.20306>, case 11: <D.20307>, case 12: <D.20309>, case 13: <D.20311>, case 14: <D.20313>, case 15: <D.20319>, case 17: <D.20321>, case 18: <D.20315>, case 20: <D.20317>, case 21: <D.20324>, case 24: <D.20304>, case 25: <D.20305>, case 27: <D.20318>, case 28: <D.20316>, case 29: <D.20314>>
  <D.20293>:
  <D.20294>:
  <D.20295>:
  {
    guint8 * p;

    p = dest;
    if (value != 0B) goto <D.23619>; else goto <D.23620>;
    <D.23619>:
    iftmp.88 = MEM[(guint8 *)value];
    goto <D.23621>;
    <D.23620>:
    iftmp.88 = 0;
    <D.23621>:
    *p = iftmp.88;
    return;
  }
  <D.20297>:
  <D.20298>:
  <D.20299>:
  {
    guint16 * p;

    p = dest;
    if (value != 0B) goto <D.23623>; else goto <D.23624>;
    <D.23623>:
    iftmp.89 = MEM[(guint16 *)value];
    goto <D.23625>;
    <D.23624>:
    iftmp.89 = 0;
    <D.23625>:
    *p = iftmp.89;
    return;
  }
  <D.20301>:
  <D.20302>:
  {
    gint32 * p;

    p = dest;
    if (value != 0B) goto <D.23627>; else goto <D.23628>;
    <D.23627>:
    iftmp.90 = MEM[(gint32 *)value];
    goto <D.23629>;
    <D.23628>:
    iftmp.90 = 0;
    <D.23629>:
    *p = iftmp.90;
    return;
  }
  <D.20304>:
  <D.20305>:
  <D.20306>:
  <D.20307>:
  {
    gint64 * p;

    p = dest;
    if (value != 0B) goto <D.23631>; else goto <D.23632>;
    <D.23631>:
    iftmp.91 = MEM[(gint64 *)value];
    goto <D.23633>;
    <D.23632>:
    iftmp.91 = 0;
    <D.23633>:
    *p = iftmp.91;
    return;
  }
  <D.20309>:
  {
    float * p;

    p = dest;
    if (value != 0B) goto <D.23635>; else goto <D.23636>;
    <D.23635>:
    iftmp.92 = MEM[(float *)value];
    goto <D.23637>;
    <D.23636>:
    iftmp.92 = 0.0;
    <D.23637>:
    *p = iftmp.92;
    return;
  }
  <D.20311>:
  {
    double * p;

    p = dest;
    if (value != 0B) goto <D.23639>; else goto <D.23640>;
    <D.23639>:
    iftmp.93 = MEM[(double *)value];
    goto <D.23641>;
    <D.23640>:
    iftmp.93 = 0.0;
    <D.23641>:
    *p = iftmp.93;
    return;
  }
  <D.20313>:
  <D.20314>:
  <D.20315>:
  <D.20316>:
  <D.20317>:
  if (deref_pointer != 0) goto <D.23643>; else goto <D.23644>;
  <D.23643>:
  iftmp.94 = MEM[(void * *)value];
  goto <D.23645>;
  <D.23644>:
  iftmp.94 = value;
  <D.23645>:
  mono_gc_wbarrier_generic_store (dest, iftmp.94);
  return;
  <D.20318>:
  <D.20319>:
  {
    void * * p;

    p = dest;
    if (deref_pointer != 0) goto <D.23647>; else goto <D.23648>;
    <D.23647>:
    iftmp.95 = MEM[(void * *)value];
    goto <D.23649>;
    <D.23648>:
    iftmp.95 = value;
    <D.23649>:
    *p = iftmp.95;
    return;
  }
  <D.20321>:
  D.23617 = type->type;
  if (D.23617 == 17) goto <D.23651>; else goto <D.23650>;
  <D.23651>:
  D.23652 = type->data.klass;
  D.23653 = BIT_FIELD_REF <*D.23652, 64, 256>;
  D.23654 = D.23653 & 16;
  if (D.23654 != 0) goto <D.23655>; else goto <D.23650>;
  <D.23655>:
  D.23652 = type->data.klass;
  D.23656 = mono_class_enum_basetype (D.23652);
  D.23657 = D.23656->type;
  t = (int) D.23657;
  goto handle_enum;
  <D.23650>:
  {
    struct MonoClass * class;
    int size;

    class = mono_class_from_mono_type (type);
    size = mono_class_value_size (class, 0B);
    if (value == 0B) goto <D.23658>; else goto <D.23659>;
    <D.23658>:
    D.23660 = (long unsigned int) size;
    mono_gc_bzero_atomic (dest, D.23660);
    goto <D.23661>;
    <D.23659>:
    mono_gc_wbarrier_value_copy (dest, value, 1, class);
    <D.23661>:
  }
  return;
  <D.20324>:
  D.23662 = type->data.generic_class;
  D.23663 = D.23662->container_class;
  D.23664 = D.23663->byval_arg.type;
  t = (int) D.23664;
  goto handle_enum;
  <D.20325>:
  D.23617 = type->type;
  D.23665 = (int) D.23617;
  monoeg_g_log (0B, 4, "got type %x", D.23665);
  <D.20326>:
  goto <D.20326>;
}


mono_field_static_set_value (struct MonoVTable * vt, struct MonoClassField * field, void * value)
{
  struct MonoType * D.23667;
  short unsigned int D.23668;
  int D.23669;
  int D.23670;
  int D.23673;
  int D.23676;
  struct MonoDomain * D.23679;
  union mono_mutex_t * D.23680;
  _Bool D.23683;
  long int D.23684;
  long int D.23685;
  struct GHashTable * D.23688;
  _Bool D.23691;
  long int D.23692;
  long int D.23693;
  long int addr.96;
  unsigned int D.23697;
  void * D.23699;
  sizetype D.23700;
  void * dest;

  D.23667 = field->type;
  D.23668 = D.23667->attrs;
  D.23669 = (int) D.23668;
  D.23670 = D.23669 & 16;
  if (D.23670 == 0) goto <D.23671>; else goto <D.23672>;
  <D.23671>:
  monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "object.c", 3024, "field->type->attrs & FIELD_ATTRIBUTE_STATIC");
  return;
  <D.23672>:
  D.23667 = field->type;
  D.23668 = D.23667->attrs;
  D.23669 = (int) D.23668;
  D.23673 = D.23669 & 64;
  if (D.23673 != 0) goto <D.23674>; else goto <D.23675>;
  <D.23674>:
  monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "object.c", 3026, "!(field->type->attrs & FIELD_ATTRIBUTE_LITERAL)");
  return;
  <D.23675>:
  D.23676 = field->offset;
  if (D.23676 == -1) goto <D.23677>; else goto <D.23678>;
  <D.23677>:
  {
    void * addr;

    {
      int ret;

      D.23679 = vt->domain;
      D.23680 = &D.23679->lock.mutex;
      ret = pthread_mutex_lock (D.23680);
      if (ret != 0) goto <D.23681>; else goto <D.23682>;
      <D.23681>:
      monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
      <D.23682>:
      D.23683 = ret != 0;
      D.23684 = (long int) D.23683;
      D.23685 = __builtin_expect (D.23684, 0);
      if (D.23685 != 0) goto <D.23686>; else goto <D.23687>;
      <D.23686>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 3032, "ret == 0");
      <D.23687>:
    }
    D.23679 = vt->domain;
    D.23688 = D.23679->special_static_fields;
    addr = monoeg_g_hash_table_lookup (D.23688, field);
    {
      int ret;

      D.23679 = vt->domain;
      D.23680 = &D.23679->lock.mutex;
      ret = pthread_mutex_unlock (D.23680);
      if (ret != 0) goto <D.23689>; else goto <D.23690>;
      <D.23689>:
      monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
      <D.23690>:
      D.23691 = ret != 0;
      D.23692 = (long int) D.23691;
      D.23693 = __builtin_expect (D.23692, 0);
      if (D.23693 != 0) goto <D.23694>; else goto <D.23695>;
      <D.23694>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 3034, "ret == 0");
      <D.23695>:
    }
    addr.96 = (long int) addr;
    D.23697 = (unsigned int) addr.96;
    dest = mono_get_special_static_data (D.23697);
  }
  goto <D.23698>;
  <D.23678>:
  D.23699 = mono_vtable_get_static_field_data (vt);
  D.23676 = field->offset;
  D.23700 = (sizetype) D.23676;
  dest = D.23699 + D.23700;
  <D.23698>:
  D.23667 = field->type;
  set_value (D.23667, dest, value, 0);
}


mono_vtable_get_static_field_data (struct MonoVTable * vt)
{
  long unsigned int D.23702;
  long unsigned int D.23703;
  void * D.23706;
  struct MonoClass * D.23707;
  int D.23708;

  D.23702 = BIT_FIELD_REF <*vt, 64, 320>;
  D.23703 = D.23702 & 134217728;
  if (D.23703 == 0) goto <D.23704>; else goto <D.23705>;
  <D.23704>:
  D.23706 = 0B;
  return D.23706;
  <D.23705>:
  D.23707 = vt->klass;
  D.23708 = D.23707->vtable_size;
  D.23706 = vt->vtable[D.23708];
  return D.23706;
}


mono_field_get_value (struct MonoObject * obj, struct MonoClassField * field, void * value)
{
  _Bool D.23710;
  long int D.23711;
  long int D.23712;
  struct MonoType * D.23715;
  short unsigned int D.23716;
  int D.23717;
  int D.23718;
  int D.23721;
  sizetype D.23722;
  void * src;

  D.23710 = obj == 0B;
  D.23711 = (long int) D.23710;
  D.23712 = __builtin_expect (D.23711, 0);
  if (D.23712 != 0) goto <D.23713>; else goto <D.23714>;
  <D.23713>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 3103, "obj");
  <D.23714>:
  D.23715 = field->type;
  D.23716 = D.23715->attrs;
  D.23717 = (int) D.23716;
  D.23718 = D.23717 & 16;
  if (D.23718 != 0) goto <D.23719>; else goto <D.23720>;
  <D.23719>:
  monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "object.c", 3105, "!(field->type->attrs & FIELD_ATTRIBUTE_STATIC)");
  return;
  <D.23720>:
  D.23721 = field->offset;
  D.23722 = (sizetype) D.23721;
  src = obj + D.23722;
  D.23715 = field->type;
  set_value (D.23715, value, src, 1);
}


mono_field_get_value_object (struct MonoDomain * domain, struct MonoClassField * field, struct MonoObject * obj)
{
  int D.23724;
  unsigned char D.23727;
  int D.23728;
  <unnamed-unsigned:1> D.23729;
  int D.23730;
  _Bool D.23731;
  struct MonoObject * D.23732;
  short unsigned int D.23733;
  int D.23734;
  int D.23735;
  int D.23738;
  struct MonoClass * D.23743;
  long unsigned int D.23744;
  long unsigned int D.23745;
  _Bool D.23749;
  long int D.23750;
  long int D.23751;
  struct MonoMethod * m.97;
  struct MonoClass * ptr_klass.100;
  struct MonoClass * tmp_klass.98;
  struct MonoImage * D.23772;
  struct MonoClass * tmp_klass.99;
  _Bool D.23774;
  long int D.23775;
  long int D.23776;
  struct MonoMethod * m.101;
  _Bool D.23780;
  long int D.23781;
  long int D.23782;
  void * * ptr.102;
  void * D.23792;
  struct MonoDomain * D.23793;
  struct MonoReflectionType * D.23794;
  int D.23795;
  guint8 * D.23798;
  struct MonoObject * o.103;
  struct MonoObject * o.104;
  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.23724 = mono_error_ok (&error);
      if (D.23724 == 0) goto <D.23725>; else goto <D.23726>;
      <D.23725>:
      mono_error_raise_exception (&error);
      <D.23726>:
      D.23727 = type->type;
      D.23728 = (int) D.23727;
      switch (D.23728) <default: <D.20398>, case 2: <D.20383>, case 3: <D.20386>, case 4: <D.20382>, case 5: <D.20381>, case 6: <D.20385>, case 7: <D.20384>, case 8: <D.20390>, case 9: <D.20389>, case 10: <D.20393>, case 11: <D.20392>, case 12: <D.20391>, case 13: <D.20394>, case 14: <D.20375>, case 15: <D.20397>, case 17: <D.20395>, case 18: <D.20377>, case 20: <D.20378>, case 21: <D.20396>, case 24: <D.20388>, case 25: <D.20387>, case 28: <D.20376>, case 29: <D.20379>>
      <D.20375>:
      <D.20376>:
      <D.20377>:
      <D.20378>:
      <D.20379>:
      is_ref = 1;
      goto <D.20380>;
      <D.20381>:
      <D.20382>:
      <D.20383>:
      <D.20384>:
      <D.20385>:
      <D.20386>:
      <D.20387>:
      <D.20388>:
      <D.20389>:
      <D.20390>:
      <D.20391>:
      <D.20392>:
      <D.20393>:
      <D.20394>:
      <D.20395>:
      D.23729 = type->byref;
      is_ref = (gboolean) D.23729;
      goto <D.20380>;
      <D.20396>:
      D.23730 = mono_type_generic_inst_is_valuetype (type);
      D.23731 = D.23730 == 0;
      is_ref = (gboolean) D.23731;
      goto <D.20380>;
      <D.20397>:
      is_ptr = 1;
      goto <D.20380>;
      <D.20398>:
      D.23727 = type->type;
      D.23728 = (int) D.23727;
      monoeg_g_log (0B, 4, "type 0x%x not handled in mono_field_get_value_object", D.23728);
      <D.20399>:
      goto <D.20399>;
      D.23732 = 0B;
      return D.23732;
      <D.20380>:
      D.23733 = type->attrs;
      D.23734 = (int) D.23733;
      D.23735 = D.23734 & 64;
      if (D.23735 != 0) goto <D.23736>; else goto <D.23737>;
      <D.23736>:
      is_literal = 1;
      <D.23737>:
      D.23733 = type->attrs;
      D.23734 = (int) D.23733;
      D.23738 = D.23734 & 16;
      if (D.23738 != 0) goto <D.23739>; else goto <D.23740>;
      <D.23739>:
      is_static = 1;
      if (is_literal == 0) goto <D.23741>; else goto <D.23742>;
      <D.23741>:
      D.23743 = field->parent;
      vtable = mono_class_vtable_full (domain, D.23743, 1);
      D.23744 = BIT_FIELD_REF <*vtable, 64, 320>;
      D.23745 = D.23744 & 33554432;
      if (D.23745 == 0) goto <D.23746>; else goto <D.23747>;
      <D.23746>:
      mono_runtime_class_init (vtable);
      <D.23747>:
      <D.23742>:
      goto <D.23748>;
      <D.23740>:
      D.23749 = obj == 0B;
      D.23750 = (long int) D.23749;
      D.23751 = __builtin_expect (D.23750, 0);
      if (D.23751 != 0) goto <D.23752>; else goto <D.23753>;
      <D.23752>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 3187, "obj");
      <D.23753>:
      <D.23748>:
      if (is_ref != 0) goto <D.23754>; else goto <D.23755>;
      <D.23754>:
      if (is_literal != 0) goto <D.23756>; else goto <D.23757>;
      <D.23756>:
      get_default_field_value (domain, field, &o);
      goto <D.23758>;
      <D.23757>:
      if (is_static != 0) goto <D.23759>; else goto <D.23760>;
      <D.23759>:
      mono_field_static_get_value (vtable, field, &o);
      goto <D.23761>;
      <D.23760>:
      mono_field_get_value (obj, field, &o);
      <D.23761>:
      <D.23758>:
      D.23732 = o;
      return D.23732;
      <D.23755>:
      if (is_ptr != 0) goto <D.23762>; else goto <D.23763>;
      <D.23762>:
      {
        static struct MonoMethod * m;
        void * args[2];
        void * * ptr;
        void * v;

        try
          {
            m.97 = m;
            if (m.97 == 0B) goto <D.23765>; else goto <D.23766>;
            <D.23765>:
            {
              struct MonoClass * ptr_klass;

              {
                static struct MonoClass * tmp_klass;

                {
                  tmp_klass.98 = tmp_klass;
                  if (tmp_klass.98 == 0B) goto <D.23768>; else goto <D.23769>;
                  <D.23768>:
                  if (0 != 0) goto <D.23770>; else goto <D.23771>;
                  <D.23770>:
                  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 3208, "mono_defaults.corlib == mono_defaults.corlib");
                  <D.23771>:
                  D.23772 = mono_defaults.corlib;
                  tmp_klass.99 = mono_class_from_name (D.23772, "System.Reflection", "Pointer");
                  tmp_klass = tmp_klass.99;
                  tmp_klass.98 = tmp_klass;
                  D.23774 = tmp_klass.98 == 0B;
                  D.23775 = (long int) D.23774;
                  D.23776 = __builtin_expect (D.23775, 0);
                  if (D.23776 != 0) goto <D.23777>; else goto <D.23778>;
                  <D.23777>:
                  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 3208, "tmp_klass");
                  <D.23778>:
                  <D.23769>:
                }
                ptr_klass.100 = tmp_klass;
              }
              ptr_klass = ptr_klass.100;
              m.101 = mono_class_get_method_from_name_flags (ptr_klass, "Box", 2, 16);
              m = m.101;
              m.97 = m;
              D.23780 = m.97 == 0B;
              D.23781 = (long int) D.23780;
              D.23782 = __builtin_expect (D.23781, 0);
              if (D.23782 != 0) goto <D.23783>; else goto <D.23784>;
              <D.23783>:
              monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 3210, "m");
              <D.23784>:
            }
            <D.23766>:
            v = &ptr;
            if (is_literal != 0) goto <D.23785>; else goto <D.23786>;
            <D.23785>:
            get_default_field_value (domain, field, v);
            goto <D.23787>;
            <D.23786>:
            if (is_static != 0) goto <D.23788>; else goto <D.23789>;
            <D.23788>:
            mono_field_static_get_value (vtable, field, v);
            goto <D.23790>;
            <D.23789>:
            mono_field_get_value (obj, field, v);
            <D.23790>:
            <D.23787>:
            ptr.102 = ptr;
            D.23792 = *ptr.102;
            args[0] = D.23792;
            D.23793 = mono_domain_get ();
            D.23794 = mono_type_get_object (D.23793, type);
            args[1] = D.23794;
            m.97 = m;
            D.23732 = mono_runtime_invoke (m.97, 0B, &args, 0B);
            return D.23732;
          }
        finally
          {
            args = {CLOBBER};
            ptr = {CLOBBER};
          }
      }
      <D.23763>:
      klass = mono_class_from_mono_type (type);
      D.23795 = mono_class_is_nullable (klass);
      if (D.23795 != 0) goto <D.23796>; else goto <D.23797>;
      <D.23796>:
      D.23798 = mono_field_get_addr (obj, vtable, field);
      D.23732 = mono_nullable_box (D.23798, klass);
      return D.23732;
      <D.23797>:
      o.103 = mono_object_new (domain, klass);
      o = o.103;
      o.104 = o;
      v = o.104 + 16;
      if (is_literal != 0) goto <D.23801>; else goto <D.23802>;
      <D.23801>:
      get_default_field_value (domain, field, v);
      goto <D.23803>;
      <D.23802>:
      if (is_static != 0) goto <D.23804>; else goto <D.23805>;
      <D.23804>:
      mono_field_static_get_value (vtable, field, v);
      goto <D.23806>;
      <D.23805>:
      mono_field_get_value (obj, field, v);
      <D.23806>:
      <D.23803>:
      D.23732 = o;
      return D.23732;
    }
  finally
    {
      o = {CLOBBER};
      error = {CLOBBER};
    }
}


mono_field_get_addr (struct MonoObject * obj, struct MonoVTable * vt, struct MonoClassField * field)
{
  struct MonoType * D.23810;
  short unsigned int D.23811;
  int D.23812;
  int D.23813;
  int D.23816;
  struct MonoDomain * D.23819;
  union mono_mutex_t * D.23820;
  _Bool D.23823;
  long int D.23824;
  long int D.23825;
  struct GHashTable * D.23828;
  _Bool D.23831;
  long int D.23832;
  long int D.23833;
  long int addr.105;
  unsigned int D.23837;
  void * D.23839;
  sizetype D.23840;
  guint8 * D.23842;
  guint8 * src;

  D.23810 = field->type;
  D.23811 = D.23810->attrs;
  D.23812 = (int) D.23811;
  D.23813 = D.23812 & 16;
  if (D.23813 != 0) goto <D.23814>; else goto <D.23815>;
  <D.23814>:
  D.23816 = field->offset;
  if (D.23816 == -1) goto <D.23817>; else goto <D.23818>;
  <D.23817>:
  {
    void * addr;

    {
      int ret;

      D.23819 = vt->domain;
      D.23820 = &D.23819->lock.mutex;
      ret = pthread_mutex_lock (D.23820);
      if (ret != 0) goto <D.23821>; else goto <D.23822>;
      <D.23821>:
      monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
      <D.23822>:
      D.23823 = ret != 0;
      D.23824 = (long int) D.23823;
      D.23825 = __builtin_expect (D.23824, 0);
      if (D.23825 != 0) goto <D.23826>; else goto <D.23827>;
      <D.23826>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 3067, "ret == 0");
      <D.23827>:
    }
    D.23819 = vt->domain;
    D.23828 = D.23819->special_static_fields;
    addr = monoeg_g_hash_table_lookup (D.23828, field);
    {
      int ret;

      D.23819 = vt->domain;
      D.23820 = &D.23819->lock.mutex;
      ret = pthread_mutex_unlock (D.23820);
      if (ret != 0) goto <D.23829>; else goto <D.23830>;
      <D.23829>:
      monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
      <D.23830>:
      D.23831 = ret != 0;
      D.23832 = (long int) D.23831;
      D.23833 = __builtin_expect (D.23832, 0);
      if (D.23833 != 0) goto <D.23834>; else goto <D.23835>;
      <D.23834>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 3069, "ret == 0");
      <D.23835>:
    }
    addr.105 = (long int) addr;
    D.23837 = (unsigned int) addr.105;
    src = mono_get_special_static_data (D.23837);
  }
  goto <D.23838>;
  <D.23818>:
  D.23839 = mono_vtable_get_static_field_data (vt);
  D.23816 = field->offset;
  D.23840 = (sizetype) D.23816;
  src = D.23839 + D.23840;
  <D.23838>:
  goto <D.23841>;
  <D.23815>:
  D.23816 = field->offset;
  D.23840 = (sizetype) D.23816;
  src = obj + D.23840;
  <D.23841>:
  D.23842 = src;
  return D.23842;
}


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

  try
    {
      data = mono_class_get_field_default_value (field, &def_type);
      def_type.106 = def_type;
      mono_get_constant_value_from_blob (domain, def_type.106, 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.107;
  char D.23846;
  short unsigned int D.23847;
  unsigned int D.23848;
  long unsigned int D.23849;
  float D.23850;
  double D.23851;
  struct MonoString * D.23852;
  int D.23853;
  int retval;
  const char * p;

  try
    {
      retval = 0;
      p = blob;
      p.107 = p;
      mono_metadata_decode_blob_size (p.107, &p);
      switch (type) <default: <D.20432>, case 2: <D.20415>, case 3: <D.20419>, case 4: <D.20417>, case 5: <D.20416>, case 6: <D.20421>, case 7: <D.20420>, case 8: <D.20423>, case 9: <D.20422>, case 10: <D.20425>, case 11: <D.20424>, case 12: <D.20426>, case 13: <D.20428>, case 14: <D.20430>, case 18: <D.20431>>
      <D.20415>:
      <D.20416>:
      <D.20417>:
      p.107 = p;
      D.23846 = *p.107;
      MEM[(guint8 *)value] = D.23846;
      goto <D.20418>;
      <D.20419>:
      <D.20420>:
      <D.20421>:
      p.107 = p;
      D.23847 = MEM[(const guint16 *)p.107];
      MEM[(guint16 *)value] = D.23847;
      goto <D.20418>;
      <D.20422>:
      <D.20423>:
      p.107 = p;
      D.23848 = MEM[(const guint32 *)p.107];
      MEM[(guint32 *)value] = D.23848;
      goto <D.20418>;
      <D.20424>:
      <D.20425>:
      p.107 = p;
      D.23849 = MEM[(const guint64 *)p.107];
      MEM[(guint64 *)value] = D.23849;
      goto <D.20418>;
      <D.20426>:
      {
        union mono_rfloat mf;

        try
          {
            p.107 = p;
            D.23848 = MEM[(const guint32 *)p.107];
            mf.ival = D.23848;
            D.23850 = mf.fval;
            MEM[(float *)value] = D.23850;
          }
        finally
          {
            mf = {CLOBBER};
          }
      }
      goto <D.20418>;
      <D.20428>:
      {
        union mono_rdouble mf;

        try
          {
            p.107 = p;
            D.23849 = MEM[(const guint64 *)p.107];
            mf.ival = D.23849;
            D.23851 = mf.fval;
            MEM[(double *)value] = D.23851;
          }
        finally
          {
            mf = {CLOBBER};
          }
      }
      goto <D.20418>;
      <D.20430>:
      D.23852 = mono_ldstr_metadata_sig (domain, blob);
      MEM[(void * *)value] = D.23852;
      goto <D.20418>;
      <D.20431>:
      MEM[(void * *)value] = 0B;
      goto <D.20418>;
      <D.20432>:
      retval = -1;
      monoeg_g_log (0B, 16, "type 0x%02x should not be in constant table", type);
      <D.20418>:
      D.23853 = retval;
      return D.23853;
    }
  finally
    {
      p = {CLOBBER};
    }
}


mono_ldstr_metadata_sig (struct MonoDomain * domain, const char * sig)
{
  const char * str.108;
  unsigned int D.23857;
  int D.23858;
  _Bool D.23861;
  long int D.23862;
  long int D.23863;
  struct MonoGHashTable * D.23866;
  _Bool D.23871;
  long int D.23872;
  long int D.23873;
  struct MonoString * D.23876;
  _Bool D.23881;
  long int D.23882;
  long int D.23883;
  const char * str;
  struct MonoString * o;
  struct MonoString * interned;
  size_t len2;

  try
    {
      str = sig;
      str.108 = str;
      D.23857 = mono_metadata_decode_blob_size (str.108, &str);
      len2 = (size_t) D.23857;
      len2 = len2 >> 1;
      str.108 = str;
      D.23858 = (int) len2;
      o = mono_string_new_utf16 (domain, str.108, D.23858);
      {
        int ret;

        ret = pthread_mutex_lock (&ldstr_section.mutex);
        if (ret != 0) goto <D.23859>; else goto <D.23860>;
        <D.23859>:
        monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
        <D.23860>:
        D.23861 = ret != 0;
        D.23862 = (long int) D.23861;
        D.23863 = __builtin_expect (D.23862, 0);
        if (D.23863 != 0) goto <D.23864>; else goto <D.23865>;
        <D.23864>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 5487, "ret == 0");
        <D.23865>:
      }
      D.23866 = domain->ldstr_table;
      interned = mono_g_hash_table_lookup (D.23866, o);
      if (interned != 0B) goto <D.23867>; else goto <D.23868>;
      <D.23867>:
      {
        int ret;

        ret = pthread_mutex_unlock (&ldstr_section.mutex);
        if (ret != 0) goto <D.23869>; else goto <D.23870>;
        <D.23869>:
        monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
        <D.23870>:
        D.23871 = ret != 0;
        D.23872 = (long int) D.23871;
        D.23873 = __builtin_expect (D.23872, 0);
        if (D.23873 != 0) goto <D.23874>; else goto <D.23875>;
        <D.23874>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 5489, "ret == 0");
        <D.23875>:
      }
      D.23876 = interned;
      return D.23876;
      <D.23868>:
      o = mono_string_get_pinned (o);
      if (o != 0B) goto <D.23877>; else goto <D.23878>;
      <D.23877>:
      D.23866 = domain->ldstr_table;
      mono_g_hash_table_insert (D.23866, o, o);
      <D.23878>:
      {
        int ret;

        ret = pthread_mutex_unlock (&ldstr_section.mutex);
        if (ret != 0) goto <D.23879>; else goto <D.23880>;
        <D.23879>:
        monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
        <D.23880>:
        D.23881 = ret != 0;
        D.23882 = (long int) D.23881;
        D.23883 = __builtin_expect (D.23882, 0);
        if (D.23883 != 0) goto <D.23884>; else goto <D.23885>;
        <D.23884>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 5497, "ret == 0");
        <D.23885>:
      }
      D.23876 = o;
      return D.23876;
    }
  finally
    {
      str = {CLOBBER};
    }
}


mono_string_get_pinned (struct MonoString * str)
{
  int D.23888;
  int D.23889;
  int D.23890;
  unsigned int D.23891;
  unsigned int D.23892;
  struct MonoVTable * D.23893;
  long unsigned int D.23894;
  mono_unichar2 * D.23897;
  mono_unichar2 * D.23898;
  int D.23899;
  int D.23900;
  long unsigned int D.23901;
  int D.23902;
  struct MonoString * D.23903;
  int size;
  struct MonoString * news;

  D.23888 = mono_string_length (str);
  D.23889 = D.23888 + 1;
  D.23890 = D.23889 * 2;
  D.23891 = (unsigned int) D.23890;
  D.23892 = D.23891 + 24;
  size = (int) D.23892;
  D.23893 = MEM[(struct MonoObject *)str].vtable;
  D.23894 = (long unsigned int) size;
  news = mono_gc_alloc_pinned_obj (D.23893, D.23894);
  if (news != 0B) goto <D.23895>; else goto <D.23896>;
  <D.23895>:
  D.23897 = mono_string_chars (news);
  D.23898 = mono_string_chars (str);
  D.23899 = mono_string_length (str);
  D.23900 = D.23899 * 2;
  D.23901 = (long unsigned int) D.23900;
  memcpy (D.23897, D.23898, D.23901);
  D.23902 = mono_string_length (str);
  news->length = D.23902;
  <D.23896>:
  D.23903 = news;
  return D.23903;
}


mono_field_static_get_value_for_thread (struct MonoInternalThread * thread, struct MonoVTable * vt, struct MonoClassField * field, void * value)
{
  struct MonoType * D.23905;
  short unsigned int D.23906;
  int D.23907;
  int D.23908;
  int D.23911;
  struct MonoDomain * D.23914;
  int D.23915;
  struct GHashTable * D.23918;
  long int addr.109;
  unsigned int D.23920;
  void * D.23922;
  sizetype D.23923;
  void * src;

  D.23905 = field->type;
  D.23906 = D.23905->attrs;
  D.23907 = (int) D.23906;
  D.23908 = D.23907 & 16;
  if (D.23908 == 0) goto <D.23909>; else goto <D.23910>;
  <D.23909>:
  monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "object.c", 3309, "field->type->attrs & FIELD_ATTRIBUTE_STATIC");
  return;
  <D.23910>:
  D.23905 = field->type;
  D.23906 = D.23905->attrs;
  D.23907 = (int) D.23906;
  D.23911 = D.23907 & 64;
  if (D.23911 != 0) goto <D.23912>; else goto <D.23913>;
  <D.23912>:
  D.23914 = vt->domain;
  get_default_field_value (D.23914, field, value);
  return;
  <D.23913>:
  D.23915 = field->offset;
  if (D.23915 == -1) goto <D.23916>; else goto <D.23917>;
  <D.23916>:
  {
    void * addr;

    D.23914 = vt->domain;
    D.23918 = D.23914->special_static_fields;
    addr = monoeg_g_hash_table_lookup (D.23918, field);
    addr.109 = (long int) addr;
    D.23920 = (unsigned int) addr.109;
    src = mono_get_special_static_data_for_thread (thread, D.23920);
  }
  goto <D.23921>;
  <D.23917>:
  D.23922 = mono_vtable_get_static_field_data (vt);
  D.23915 = field->offset;
  D.23923 = (sizetype) D.23915;
  src = D.23922 + D.23923;
  <D.23921>:
  D.23905 = field->type;
  set_value (D.23905, value, src, 1);
}


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

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


mono_property_set_value (struct MonoProperty * prop, void * obj, void * * params, struct MonoObject * * exc)
{
  struct MonoObject * (*<T12ee>) (struct MonoMethod *, void *, void * *, struct MonoObject * *) default_mono_runtime_invoke.110;
  struct MonoMethod * D.23928;

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


mono_property_get_value (struct MonoProperty * prop, void * obj, void * * params, struct MonoObject * * exc)
{
  struct MonoObject * D.23929;
  struct MonoObject * (*<T12ee>) (struct MonoMethod *, void *, void * *, struct MonoObject * *) default_mono_runtime_invoke.111;
  struct MonoMethod * D.23931;

  default_mono_runtime_invoke.111 = default_mono_runtime_invoke;
  D.23931 = prop->get;
  D.23929 = default_mono_runtime_invoke.111 (D.23931, obj, params, exc);
  return D.23929;
}


mono_nullable_init (guint8 * buf, struct MonoObject * value, struct MonoClass * klass)
{
  long unsigned int D.23933;
  long unsigned int D.23934;
  _Bool D.23935;
  long int D.23936;
  long int D.23937;
  struct MonoClassField * D.23940;
  struct MonoType * D.23941;
  struct MonoClass * D.23942;
  _Bool D.23943;
  long int D.23944;
  long int D.23945;
  struct MonoClassField * D.23948;
  struct MonoType * D.23949;
  struct MonoClass * D.23950;
  struct MonoClass * D.23951;
  _Bool D.23952;
  long int D.23953;
  long int D.23954;
  int D.23957;
  sizetype D.23958;
  sizetype D.23959;
  guint8 * D.23960;
  _Bool D.23961;
  unsigned char D.23962;
  long unsigned int D.23965;
  long unsigned int D.23966;
  int D.23969;
  sizetype D.23970;
  sizetype D.23971;
  guint8 * D.23972;
  void * D.23973;
  void * D.23975;
  int D.23976;
  long unsigned int D.23977;
  int D.23979;
  long unsigned int D.23980;
  struct MonoClass * param_class;

  param_class = klass->cast_class;
  mono_class_setup_fields_locking (klass);
  D.23933 = BIT_FIELD_REF <*klass, 64, 256>;
  D.23934 = D.23933 & 137438953472;
  D.23935 = D.23934 == 0;
  D.23936 = (long int) D.23935;
  D.23937 = __builtin_expect (D.23936, 0);
  if (D.23937 != 0) goto <D.23938>; else goto <D.23939>;
  <D.23938>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 3412, "klass->fields_inited");
  <D.23939>:
  D.23940 = klass->fields;
  D.23941 = D.23940->type;
  D.23942 = mono_class_from_mono_type (D.23941);
  D.23943 = D.23942 != param_class;
  D.23944 = (long int) D.23943;
  D.23945 = __builtin_expect (D.23944, 0);
  if (D.23945 != 0) goto <D.23946>; else goto <D.23947>;
  <D.23946>:
  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.23947>:
  D.23940 = klass->fields;
  D.23948 = D.23940 + 32;
  D.23949 = D.23948->type;
  D.23950 = mono_class_from_mono_type (D.23949);
  D.23951 = mono_defaults.boolean_class;
  D.23952 = D.23950 != D.23951;
  D.23953 = (long int) D.23952;
  D.23954 = __builtin_expect (D.23953, 0);
  if (D.23954 != 0) goto <D.23955>; else goto <D.23956>;
  <D.23955>:
  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.23956>:
  D.23940 = klass->fields;
  D.23948 = D.23940 + 32;
  D.23957 = D.23948->offset;
  D.23958 = (sizetype) D.23957;
  D.23959 = D.23958 + 18446744073709551600;
  D.23960 = buf + D.23959;
  D.23961 = value != 0B;
  D.23962 = (unsigned char) D.23961;
  *D.23960 = D.23962;
  if (value != 0B) goto <D.23963>; else goto <D.23964>;
  <D.23963>:
  D.23965 = BIT_FIELD_REF <*param_class, 64, 256>;
  D.23966 = D.23965 & 134217728;
  if (D.23966 != 0) goto <D.23967>; else goto <D.23968>;
  <D.23967>:
  D.23940 = klass->fields;
  D.23969 = D.23940->offset;
  D.23970 = (sizetype) D.23969;
  D.23971 = D.23970 + 18446744073709551600;
  D.23972 = buf + D.23971;
  D.23973 = mono_object_unbox (value);
  mono_gc_wbarrier_value_copy (D.23972, D.23973, 1, param_class);
  goto <D.23974>;
  <D.23968>:
  D.23940 = klass->fields;
  D.23969 = D.23940->offset;
  D.23970 = (sizetype) D.23969;
  D.23971 = D.23970 + 18446744073709551600;
  D.23972 = buf + D.23971;
  D.23975 = mono_object_unbox (value);
  D.23976 = mono_class_value_size (param_class, 0B);
  D.23977 = (long unsigned int) D.23976;
  mono_gc_memmove_atomic (D.23972, D.23975, D.23977);
  <D.23974>:
  goto <D.23978>;
  <D.23964>:
  D.23940 = klass->fields;
  D.23969 = D.23940->offset;
  D.23970 = (sizetype) D.23969;
  D.23971 = D.23970 + 18446744073709551600;
  D.23972 = buf + D.23971;
  D.23979 = mono_class_value_size (param_class, 0B);
  D.23980 = (long unsigned int) D.23979;
  mono_gc_bzero_atomic (D.23972, D.23980);
  <D.23978>:
}


mono_nullable_box (guint8 * buf, struct MonoClass * klass)
{
  long unsigned int D.23981;
  long unsigned int D.23982;
  _Bool D.23983;
  long int D.23984;
  long int D.23985;
  struct MonoClassField * D.23988;
  struct MonoType * D.23989;
  struct MonoClass * D.23990;
  _Bool D.23991;
  long int D.23992;
  long int D.23993;
  struct MonoClassField * D.23996;
  struct MonoType * D.23997;
  struct MonoClass * D.23998;
  struct MonoClass * D.23999;
  _Bool D.24000;
  long int D.24001;
  long int D.24002;
  int D.24005;
  sizetype D.24006;
  sizetype D.24007;
  guint8 * D.24008;
  unsigned char D.24009;
  struct MonoDomain * D.24012;
  long unsigned int D.24013;
  long unsigned int D.24014;
  void * D.24017;
  int D.24018;
  sizetype D.24019;
  sizetype D.24020;
  guint8 * D.24021;
  void * D.24023;
  int D.24024;
  long unsigned int D.24025;
  struct MonoObject * D.24026;
  struct MonoClass * param_class;

  param_class = klass->cast_class;
  mono_class_setup_fields_locking (klass);
  D.23981 = BIT_FIELD_REF <*klass, 64, 256>;
  D.23982 = D.23981 & 137438953472;
  D.23983 = D.23982 == 0;
  D.23984 = (long int) D.23983;
  D.23985 = __builtin_expect (D.23984, 0);
  if (D.23985 != 0) goto <D.23986>; else goto <D.23987>;
  <D.23986>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 3442, "klass->fields_inited");
  <D.23987>:
  D.23988 = klass->fields;
  D.23989 = D.23988->type;
  D.23990 = mono_class_from_mono_type (D.23989);
  D.23991 = D.23990 != param_class;
  D.23992 = (long int) D.23991;
  D.23993 = __builtin_expect (D.23992, 0);
  if (D.23993 != 0) goto <D.23994>; else goto <D.23995>;
  <D.23994>:
  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.23995>:
  D.23988 = klass->fields;
  D.23996 = D.23988 + 32;
  D.23997 = D.23996->type;
  D.23998 = mono_class_from_mono_type (D.23997);
  D.23999 = mono_defaults.boolean_class;
  D.24000 = D.23998 != D.23999;
  D.24001 = (long int) D.24000;
  D.24002 = __builtin_expect (D.24001, 0);
  if (D.24002 != 0) goto <D.24003>; else goto <D.24004>;
  <D.24003>:
  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.24004>:
  D.23988 = klass->fields;
  D.23996 = D.23988 + 32;
  D.24005 = D.23996->offset;
  D.24006 = (sizetype) D.24005;
  D.24007 = D.24006 + 18446744073709551600;
  D.24008 = buf + D.24007;
  D.24009 = *D.24008;
  if (D.24009 != 0) goto <D.24010>; else goto <D.24011>;
  <D.24010>:
  {
    struct MonoObject * o;

    D.24012 = mono_domain_get ();
    o = mono_object_new (D.24012, param_class);
    D.24013 = BIT_FIELD_REF <*param_class, 64, 256>;
    D.24014 = D.24013 & 134217728;
    if (D.24014 != 0) goto <D.24015>; else goto <D.24016>;
    <D.24015>:
    D.24017 = mono_object_unbox (o);
    D.23988 = klass->fields;
    D.24018 = D.23988->offset;
    D.24019 = (sizetype) D.24018;
    D.24020 = D.24019 + 18446744073709551600;
    D.24021 = buf + D.24020;
    mono_gc_wbarrier_value_copy (D.24017, D.24021, 1, param_class);
    goto <D.24022>;
    <D.24016>:
    D.24023 = mono_object_unbox (o);
    D.23988 = klass->fields;
    D.24018 = D.23988->offset;
    D.24019 = (sizetype) D.24018;
    D.24020 = D.24019 + 18446744073709551600;
    D.24021 = buf + D.24020;
    D.24024 = mono_class_value_size (param_class, 0B);
    D.24025 = (long unsigned int) D.24024;
    mono_gc_memmove_atomic (D.24023, D.24021, D.24025);
    <D.24022>:
    D.24026 = o;
    return D.24026;
  }
  <D.24011>:
  D.24026 = 0B;
  return D.24026;
}


mono_get_delegate_invoke (struct MonoClass * klass)
{
  unsigned char D.24028;
  struct MonoMethod * D.24031;
  struct MonoMethod * im;

  mono_class_setup_methods (klass);
  D.24028 = klass->exception_type;
  if (D.24028 != 0) goto <D.24029>; else goto <D.24030>;
  <D.24029>:
  D.24031 = 0B;
  return D.24031;
  <D.24030>:
  im = mono_class_get_method_from_name (klass, "Invoke", -1);
  D.24031 = im;
  return D.24031;
}


mono_get_delegate_begin_invoke (struct MonoClass * klass)
{
  unsigned char D.24033;
  struct MonoMethod * D.24036;
  struct MonoMethod * im;

  mono_class_setup_methods (klass);
  D.24033 = klass->exception_type;
  if (D.24033 != 0) goto <D.24034>; else goto <D.24035>;
  <D.24034>:
  D.24036 = 0B;
  return D.24036;
  <D.24035>:
  im = mono_class_get_method_from_name (klass, "BeginInvoke", -1);
  D.24036 = im;
  return D.24036;
}


mono_get_delegate_end_invoke (struct MonoClass * klass)
{
  unsigned char D.24038;
  struct MonoMethod * D.24041;
  struct MonoMethod * im;

  mono_class_setup_methods (klass);
  D.24038 = klass->exception_type;
  if (D.24038 != 0) goto <D.24039>; else goto <D.24040>;
  <D.24039>:
  D.24041 = 0B;
  return D.24041;
  <D.24040>:
  im = mono_class_get_method_from_name (klass, "EndInvoke", -1);
  D.24041 = im;
  return D.24041;
}


mono_runtime_delegate_invoke (struct MonoObject * delegate, void * * params, struct MonoObject * * exc)
{
  struct MonoVTable * D.24043;
  char * D.24046;
  struct MonoObject * D.24047;
  struct MonoMethod * im;
  struct MonoClass * klass;

  D.24043 = delegate->vtable;
  klass = D.24043->klass;
  im = mono_get_delegate_invoke (klass);
  if (im == 0B) goto <D.24044>; else goto <D.24045>;
  <D.24044>:
  D.24046 = mono_type_get_full_name (klass);
  monoeg_g_log (0B, 4, "Could not lookup delegate invoke method for delegate %s", D.24046);
  <D.20496>:
  goto <D.20496>;
  <D.24045>:
  D.24047 = mono_runtime_invoke (im, delegate, params, exc);
  return D.24047;
}


mono_runtime_get_main_args ()
{
  char * * main_args.112;
  struct MonoArray * D.24052;
  struct MonoClass * D.24053;
  int num_main_args.113;
  long unsigned int D.24055;
  long unsigned int D.24056;
  long unsigned int D.24057;
  long unsigned int D.24058;
  char * * D.24059;
  char * D.24060;
  struct MonoString * D.24061;
  struct MonoArray * res;
  int i;
  struct MonoDomain * domain;

  domain = mono_domain_get ();
  main_args.112 = main_args;
  if (main_args.112 == 0B) goto <D.24050>; else goto <D.24051>;
  <D.24050>:
  D.24052 = 0B;
  return D.24052;
  <D.24051>:
  D.24053 = mono_defaults.string_class;
  num_main_args.113 = num_main_args;
  D.24055 = (long unsigned int) num_main_args.113;
  res = mono_array_new (domain, D.24053, D.24055);
  i = 0;
  goto <D.20507>;
  <D.20506>:
  {
    void * * __p;

    D.24056 = (long unsigned int) i;
    __p = mono_array_addr_with_size (res, 8, D.24056);
    main_args.112 = main_args;
    D.24057 = (long unsigned int) i;
    D.24058 = D.24057 * 8;
    D.24059 = main_args.112 + D.24058;
    D.24060 = *D.24059;
    D.24061 = mono_string_new (domain, D.24060);
    mono_gc_wbarrier_set_arrayref (res, __p, D.24061);
  }
  i = i + 1;
  <D.20507>:
  num_main_args.113 = num_main_args;
  if (i < num_main_args.113) goto <D.20506>; else goto <D.20508>;
  <D.20508>:
  D.24052 = res;
  return D.24052;
}


mono_runtime_run_main (struct MonoMethod * method, int argc, char * * argv, struct MonoObject * * exc)
{
  _Bool D.24063;
  long int D.24064;
  long int D.24065;
  struct MonoThread * D.24068;
  long unsigned int D.24069;
  long unsigned int D.24070;
  void * main_args.114;
  char * D.24072;
  int D.24073;
  struct MonoClass * D.24076;
  struct MonoImage * D.24077;
  struct MonoAssembly * D.24078;
  char * D.24079;
  char * * main_args.115;
  long unsigned int D.24086;
  long unsigned int D.24087;
  char * * D.24088;
  char * D.24089;
  char * * D.24092;
  short unsigned int D.24095;
  struct MonoClass * D.24098;
  long unsigned int D.24099;
  long unsigned int D.24100;
  int D.24102;
  int i;
  struct MonoArray * args;
  struct MonoDomain * domain;
  gchar * utf8_fullpath;
  struct MonoMethodSignature * sig;

  args = 0B;
  domain = mono_domain_get ();
  D.24063 = method == 0B;
  D.24064 = (long int) D.24063;
  D.24065 = __builtin_expect (D.24064, 0);
  if (D.24065 != 0) goto <D.24066>; else goto <D.24067>;
  <D.24066>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 3601, "method != NULL");
  <D.24067>:
  D.24068 = mono_thread_current ();
  mono_thread_set_main (D.24068);
  D.24069 = (long unsigned int) argc;
  D.24070 = D.24069 * 8;
  main_args.114 = monoeg_malloc0 (D.24070);
  main_args = main_args.114;
  num_main_args = argc;
  D.24072 = *argv;
  D.24073 = monoeg_g_path_is_absolute (D.24072);
  if (D.24073 == 0) goto <D.24074>; else goto <D.24075>;
  <D.24074>:
  {
    gchar * basename;
    gchar * fullpath;

    D.24072 = *argv;
    basename = monoeg_g_path_get_basename (D.24072);
    D.24076 = method->klass;
    D.24077 = D.24076->image;
    D.24078 = D.24077->assembly;
    D.24079 = D.24078->basedir;
    fullpath = monoeg_g_build_path ("/", D.24079, basename, 0B);
    utf8_fullpath = mono_utf8_from_external (fullpath);
    if (utf8_fullpath == 0B) goto <D.24080>; else goto <D.24081>;
    <D.24080>:
    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.24081>:
    monoeg_g_free (fullpath);
    monoeg_g_free (basename);
  }
  goto <D.24082>;
  <D.24075>:
  D.24072 = *argv;
  utf8_fullpath = mono_utf8_from_external (D.24072);
  if (utf8_fullpath == 0B) goto <D.24083>; else goto <D.24084>;
  <D.24083>:
  D.24072 = *argv;
  monoeg_g_print ("\nCannot determine the text encoding for the assembly location: %s\n", D.24072);
  monoeg_g_print ("Please add the correct encoding to MONO_EXTERNAL_ENCODINGS and try again.\n");
  exit (-1);
  <D.24084>:
  <D.24082>:
  main_args.115 = main_args;
  *main_args.115 = utf8_fullpath;
  i = 1;
  goto <D.20531>;
  <D.20530>:
  {
    gchar * utf8_arg;

    D.24086 = (long unsigned int) i;
    D.24087 = D.24086 * 8;
    D.24088 = argv + D.24087;
    D.24089 = *D.24088;
    utf8_arg = mono_utf8_from_external (D.24089);
    if (utf8_arg == 0B) goto <D.24090>; else goto <D.24091>;
    <D.24090>:
    D.24086 = (long unsigned int) i;
    D.24087 = D.24086 * 8;
    D.24088 = argv + D.24087;
    D.24089 = *D.24088;
    monoeg_g_print ("\nCannot determine the text encoding for argument %d (%s).\n", i, D.24089);
    monoeg_g_print ("Please add the correct encoding to MONO_EXTERNAL_ENCODINGS and try again.\n");
    exit (-1);
    <D.24091>:
    main_args.115 = main_args;
    D.24086 = (long unsigned int) i;
    D.24087 = D.24086 * 8;
    D.24092 = main_args.115 + D.24087;
    *D.24092 = utf8_arg;
  }
  i = i + 1;
  <D.20531>:
  if (i < argc) goto <D.20530>; else goto <D.20532>;
  <D.20532>:
  argc = argc + -1;
  argv = argv + 8;
  sig = mono_method_signature (method);
  if (sig == 0B) goto <D.24093>; else goto <D.24094>;
  <D.24093>:
  monoeg_g_print ("Unable to load Main method.\n");
  exit (-1);
  <D.24094>:
  D.24095 = sig->param_count;
  if (D.24095 != 0) goto <D.24096>; else goto <D.24097>;
  <D.24096>:
  D.24098 = mono_defaults.string_class;
  D.24099 = (long unsigned int) argc;
  args = mono_array_new (domain, D.24098, D.24099);
  i = 0;
  goto <D.20537>;
  <D.20536>:
  {
    gchar * str;
    struct MonoString * arg;

    D.24086 = (long unsigned int) i;
    D.24087 = D.24086 * 8;
    D.24088 = argv + D.24087;
    D.24089 = *D.24088;
    str = mono_utf8_from_external (D.24089);
    arg = mono_string_new (domain, str);
    {
      void * * __p;

      D.24100 = (long unsigned int) i;
      __p = mono_array_addr_with_size (args, 8, D.24100);
      mono_gc_wbarrier_set_arrayref (args, __p, arg);
    }
    monoeg_g_free (str);
  }
  i = i + 1;
  <D.20537>:
  if (i < argc) goto <D.20536>; else goto <D.20538>;
  <D.20538>:
  goto <D.24101>;
  <D.24097>:
  D.24098 = mono_defaults.string_class;
  args = mono_array_new (domain, D.24098, 0);
  <D.24101>:
  D.24076 = method->klass;
  D.24077 = D.24076->image;
  D.24078 = D.24077->assembly;
  mono_assembly_set_main (D.24078);
  D.24102 = mono_runtime_exec_main (method, args, exc);
  return D.24102;
}


mono_object_xdomain_representation (struct MonoObject * obj, struct MonoDomain * target_domain, struct MonoObject * * exc)
{
  struct MonoVTable * D.24104;
  struct MonoClass * D.24105;
  long unsigned int D.24106;
  long unsigned int D.24107;
  struct MonoDomain * D.24111;
  int failure.116;
  struct MonoObject * D.24117;
  struct MonoObject * deserialized;
  gboolean failure;

  try
    {
      deserialized = 0B;
      failure = 0;
      *exc = 0B;
      D.24104 = obj->vtable;
      D.24105 = D.24104->klass;
      D.24106 = BIT_FIELD_REF <*D.24105, 64, 256>;
      D.24107 = D.24106 & 4194304;
      if (D.24107 != 0) goto <D.24108>; else goto <D.24109>;
      <D.24108>:
      deserialized = make_transparent_proxy (obj, &failure, exc);
      goto <D.24110>;
      <D.24109>:
      {
        struct MonoDomain * domain;
        struct MonoObject * serialized;

        domain = mono_domain_get ();
        D.24104 = obj->vtable;
        D.24111 = D.24104->domain;
        mono_domain_set_internal_with_options (D.24111, 0);
        serialized = serialize_object (obj, &failure, exc);
        mono_domain_set_internal_with_options (target_domain, 0);
        failure.116 = failure;
        if (failure.116 == 0) goto <D.24113>; else goto <D.24114>;
        <D.24113>:
        deserialized = deserialize_object (serialized, &failure, exc);
        <D.24114>:
        if (domain != target_domain) goto <D.24115>; else goto <D.24116>;
        <D.24115>:
        mono_domain_set_internal_with_options (domain, 0);
        <D.24116>:
      }
      <D.24110>:
      D.24117 = deserialized;
      return D.24117;
    }
  finally
    {
      failure = {CLOBBER};
    }
}


make_transparent_proxy (struct MonoObject * obj, gboolean * failure, struct MonoObject * * exc)
{
  struct MonoMethod * get_proxy_method.117;
  struct MonoClass * D.24123;
  struct MonoMethod * get_proxy_method.118;
  struct MonoVTable * D.24125;
  struct MonoClass * D.24126;
  long unsigned int D.24127;
  long unsigned int D.24128;
  _Bool D.24129;
  long int D.24130;
  long int D.24131;
  struct MonoType * D.24134;
  struct MonoReflectionType * * D.24135;
  struct MonoObject * * D.24136;
  struct MonoObject * D.24137;
  struct MonoObject * D.24140;
  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.117 = get_proxy_method;
  if (get_proxy_method.117 == 0B) goto <D.24121>; else goto <D.24122>;
  <D.24121>:
  D.24123 = mono_defaults.real_proxy_class;
  get_proxy_method.118 = mono_class_get_method_from_name (D.24123, "GetTransparentProxy", 0);
  get_proxy_method = get_proxy_method.118;
  <D.24122>:
  D.24125 = obj->vtable;
  D.24126 = D.24125->klass;
  D.24127 = BIT_FIELD_REF <*D.24126, 64, 256>;
  D.24128 = D.24127 & 4194304;
  D.24129 = D.24128 == 0;
  D.24130 = (long int) D.24129;
  D.24131 = __builtin_expect (D.24130, 0);
  if (D.24131 != 0) goto <D.24132>; else goto <D.24133>;
  <D.24132>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 3751, "mono_class_is_marshalbyref (obj->vtable->klass)");
  <D.24133>:
  D.24123 = mono_defaults.real_proxy_class;
  real_proxy = mono_object_new (domain, D.24123);
  D.24125 = obj->vtable;
  D.24126 = D.24125->klass;
  D.24134 = &D.24126->byval_arg;
  reflection_type = mono_type_get_object (domain, D.24134);
  D.24135 = &real_proxy->class_to_proxy;
  mono_gc_wbarrier_set_field (real_proxy, D.24135, reflection_type);
  D.24136 = &real_proxy->unwrapped_server;
  mono_gc_wbarrier_set_field (real_proxy, D.24136, obj);
  *exc = 0B;
  get_proxy_method.117 = get_proxy_method;
  transparent_proxy = mono_runtime_invoke (get_proxy_method.117, real_proxy, 0B, exc);
  D.24137 = *exc;
  if (D.24137 != 0B) goto <D.24138>; else goto <D.24139>;
  <D.24138>:
  *failure = 1;
  <D.24139>:
  D.24140 = transparent_proxy;
  return D.24140;
}


serialize_object (struct MonoObject * obj, gboolean * failure, struct MonoObject * * exc)
{
  struct MonoMethod * serialize_method.119;
  struct MonoImage * D.24145;
  struct MonoMethod * serialize_method.120;
  struct MonoObject * D.24149;
  struct MonoVTable * D.24150;
  struct MonoClass * D.24151;
  long unsigned int D.24152;
  long unsigned int D.24153;
  _Bool D.24154;
  long int D.24155;
  long int D.24156;
  struct MonoObject * D.24159;
  static struct MonoMethod * serialize_method;
  void * params[1];
  struct MonoObject * array;

  try
    {
      serialize_method.119 = serialize_method;
      if (serialize_method.119 == 0B) goto <D.24143>; else goto <D.24144>;
      <D.24143>:
      {
        struct MonoClass * klass;

        D.24145 = mono_defaults.corlib;
        klass = mono_class_from_name (D.24145, "System.Runtime.Remoting", "RemotingServices");
        serialize_method.120 = mono_class_get_method_from_name (klass, "SerializeCallData", -1);
        serialize_method = serialize_method.120;
      }
      <D.24144>:
      serialize_method.119 = serialize_method;
      if (serialize_method.119 == 0B) goto <D.24147>; else goto <D.24148>;
      <D.24147>:
      *failure = 1;
      D.24149 = 0B;
      return D.24149;
      <D.24148>:
      D.24150 = obj->vtable;
      D.24151 = D.24150->klass;
      D.24152 = BIT_FIELD_REF <*D.24151, 64, 256>;
      D.24153 = D.24152 & 4194304;
      D.24154 = D.24153 != 0;
      D.24155 = (long int) D.24154;
      D.24156 = __builtin_expect (D.24155, 0);
      if (D.24156 != 0) goto <D.24157>; else goto <D.24158>;
      <D.24157>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 3700, "!mono_class_is_marshalbyref (mono_object_class (obj))");
      <D.24158>:
      params[0] = obj;
      *exc = 0B;
      serialize_method.119 = serialize_method;
      array = mono_runtime_invoke (serialize_method.119, 0B, &params, exc);
      D.24159 = *exc;
      if (D.24159 != 0B) goto <D.24160>; else goto <D.24161>;
      <D.24160>:
      *failure = 1;
      <D.24161>:
      D.24149 = array;
      return D.24149;
    }
  finally
    {
      params = {CLOBBER};
    }
}


deserialize_object (struct MonoObject * obj, gboolean * failure, struct MonoObject * * exc)
{
  struct MonoMethod * deserialize_method.121;
  struct MonoImage * D.24167;
  struct MonoMethod * deserialize_method.122;
  struct MonoObject * D.24171;
  struct MonoObject * D.24172;
  static struct MonoMethod * deserialize_method;
  void * params[1];
  struct MonoObject * result;

  try
    {
      deserialize_method.121 = deserialize_method;
      if (deserialize_method.121 == 0B) goto <D.24165>; else goto <D.24166>;
      <D.24165>:
      {
        struct MonoClass * klass;

        D.24167 = mono_defaults.corlib;
        klass = mono_class_from_name (D.24167, "System.Runtime.Remoting", "RemotingServices");
        deserialize_method.122 = mono_class_get_method_from_name (klass, "DeserializeCallData", -1);
        deserialize_method = deserialize_method.122;
      }
      <D.24166>:
      deserialize_method.121 = deserialize_method;
      if (deserialize_method.121 == 0B) goto <D.24169>; else goto <D.24170>;
      <D.24169>:
      *failure = 1;
      D.24171 = 0B;
      return D.24171;
      <D.24170>:
      params[0] = obj;
      *exc = 0B;
      deserialize_method.121 = deserialize_method;
      result = mono_runtime_invoke (deserialize_method.121, 0B, &params, exc);
      D.24172 = *exc;
      if (D.24172 != 0B) goto <D.24173>; else goto <D.24174>;
      <D.24173>:
      *failure = 1;
      <D.24174>:
      D.24171 = result;
      return D.24171;
    }
  finally
    {
      params = {CLOBBER};
    }
}


mono_runtime_unhandled_exception_policy_set (MonoRuntimeUnhandledExceptionPolicy policy)
{
  runtime_unhandled_exception_policy = policy;
}


mono_runtime_unhandled_exception_policy_get ()
{
  MonoRuntimeUnhandledExceptionPolicy D.24177;

  D.24177 = runtime_unhandled_exception_policy;
  return D.24177;
}


mono_unhandled_exception (struct MonoObject * exc)
{
  struct MonoClass * D.24179;
  _Bool D.24180;
  long int D.24181;
  long int D.24182;
  struct MonoVTable * D.24185;
  struct MonoClass * D.24186;
  struct MonoClass * D.24187;
  int iftmp.123;
  struct MonoThread * main_thread.124;
  struct MonoInternalThread * D.24197;
  struct _MonoInternalThread * D.24198;
  <unnamed type> D.24199;
  struct MonoAppDomain * D.24200;
  int D.24201;
  sizetype D.24202;
  struct MonoObject * * D.24203;
  struct MonoAppDomain * D.24206;
  struct MonoObject * * D.24207;
  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.24179 = mono_defaults.appdomain_class;
  field = mono_class_get_field_from_name (D.24179, "UnhandledException");
  D.24180 = field == 0B;
  D.24181 = (long int) D.24180;
  D.24182 = __builtin_expect (D.24181, 0);
  if (D.24182 != 0) goto <D.24183>; else goto <D.24184>;
  <D.24183>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 3940, "field");
  <D.24184>:
  D.24185 = exc->vtable;
  D.24186 = D.24185->klass;
  D.24187 = mono_defaults.threadabortexception_class;
  if (D.24186 != D.24187) goto <D.24188>; else goto <D.24189>;
  <D.24188>:
  {
    gboolean abort_process;

    main_thread.124 = main_thread;
    if (main_thread.124 != 0B) goto <D.24196>; else goto <D.24191>;
    <D.24196>:
    D.24197 = mono_thread_internal_current ();
    main_thread.124 = main_thread;
    D.24198 = main_thread.124->internal_thread;
    if (D.24197 == D.24198) goto <D.24192>; else goto <D.24191>;
    <D.24191>:
    D.24199 = mono_runtime_unhandled_exception_policy_get ();
    if (D.24199 == 1) goto <D.24192>; else goto <D.24193>;
    <D.24192>:
    iftmp.123 = 1;
    goto <D.24194>;
    <D.24193>:
    iftmp.123 = 0;
    <D.24194>:
    abort_process = iftmp.123;
    D.24200 = root_domain->domain;
    D.24201 = field->offset;
    D.24202 = (sizetype) D.24201;
    D.24203 = D.24200 + D.24202;
    root_appdomain_delegate = *D.24203;
    if (current_domain != root_domain) goto <D.24204>; else goto <D.24205>;
    <D.24204>:
    D.24206 = current_domain->domain;
    D.24201 = field->offset;
    D.24202 = (sizetype) D.24201;
    D.24207 = D.24206 + D.24202;
    current_appdomain_delegate = *D.24207;
    goto <D.24208>;
    <D.24205>:
    current_appdomain_delegate = 0B;
    <D.24208>:
    if (current_appdomain_delegate == 0B) goto <D.24211>; else goto <D.24209>;
    <D.24211>:
    if (root_appdomain_delegate == 0B) goto <D.24212>; else goto <D.24209>;
    <D.24212>:
    if (abort_process != 0) goto <D.24213>; else goto <D.24214>;
    <D.24213>:
    mono_environment_exitcode_set (1);
    <D.24214>:
    mono_print_unhandled_exception (exc);
    goto <D.24210>;
    <D.24209>:
    if (root_appdomain_delegate != 0B) goto <D.24215>; else goto <D.24216>;
    <D.24215>:
    call_unhandled_exception_delegate (root_domain, root_appdomain_delegate, exc);
    <D.24216>:
    if (current_appdomain_delegate != 0B) goto <D.24217>; else goto <D.24218>;
    <D.24217>:
    call_unhandled_exception_delegate (current_domain, current_appdomain_delegate, exc);
    <D.24218>:
    <D.24210>:
  }
  <D.24189>:
}


call_unhandled_exception_delegate (struct MonoDomain * domain, struct MonoObject * delegate, struct MonoObject * exc)
{
  struct MonoAppDomain * D.24221;
  struct MonoVTable * D.24222;
  struct MonoDomain * D.24223;
  _Bool D.24224;
  long int D.24225;
  long int D.24226;
  struct MonoVTable * D.24229;
  struct MonoDomain * D.24230;
  struct MonoObject * serialization_exc.125;
  _Bool D.24238;
  long int D.24239;
  long int D.24240;
  struct MonoImage * D.24244;
  _Bool D.24245;
  long int D.24246;
  long int D.24247;
  struct MonoObject * D.24250;
  struct MonoObject * e.126;
  struct MonoString * D.24256;
  int D.24257;
  struct MonoObject * e;
  void * pa[2];
  struct MonoDomain * current_domain;

  try
    {
      e = 0B;
      current_domain = mono_domain_get ();
      if (domain != current_domain) goto <D.24219>; else goto <D.24220>;
      <D.24219>:
      mono_domain_set_internal_with_options (domain, 0);
      <D.24220>:
      D.24221 = domain->domain;
      D.24222 = MEM[(struct MonoObject *)D.24221].vtable;
      D.24223 = D.24222->domain;
      D.24224 = D.24223 != domain;
      D.24225 = (long int) D.24224;
      D.24226 = __builtin_expect (D.24225, 0);
      if (D.24226 != 0) goto <D.24227>; else goto <D.24228>;
      <D.24227>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 3850, "domain == mono_object_domain (domain->domain)");
      <D.24228>:
      D.24229 = exc->vtable;
      D.24230 = D.24229->domain;
      if (D.24230 != domain) goto <D.24231>; else goto <D.24232>;
      <D.24231>:
      {
        struct MonoObject * serialization_exc;

        try
          {
            exc = mono_object_xdomain_representation (exc, domain, &serialization_exc);
            if (exc == 0B) goto <D.24233>; else goto <D.24234>;
            <D.24233>:
            serialization_exc.125 = serialization_exc;
            if (serialization_exc.125 != 0B) goto <D.24236>; else goto <D.24237>;
            <D.24236>:
            {
              struct MonoObject * dummy;

              try
                {
                  serialization_exc.125 = serialization_exc;
                  exc = mono_object_xdomain_representation (serialization_exc.125, domain, &dummy);
                  D.24238 = exc == 0B;
                  D.24239 = (long int) D.24238;
                  D.24240 = __builtin_expect (D.24239, 0);
                  if (D.24240 != 0) goto <D.24241>; else goto <D.24242>;
                  <D.24241>:
                  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 3860, "exc");
                  <D.24242>:
                }
              finally
                {
                  dummy = {CLOBBER};
                }
            }
            goto <D.24243>;
            <D.24237>:
            D.24244 = mono_get_corlib ();
            exc = mono_exception_from_name_msg (D.24244, "System.Runtime.Serialization", "SerializationException", "Could not serialize unhandled exception.");
            <D.24243>:
            <D.24234>:
          }
        finally
          {
            serialization_exc = {CLOBBER};
          }
      }
      <D.24232>:
      D.24229 = exc->vtable;
      D.24230 = D.24229->domain;
      D.24245 = D.24230 != domain;
      D.24246 = (long int) D.24245;
      D.24247 = __builtin_expect (D.24246, 0);
      if (D.24247 != 0) goto <D.24248>; else goto <D.24249>;
      <D.24248>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 3868, "mono_object_domain (exc) == domain");
      <D.24249>:
      D.24221 = domain->domain;
      pa[0] = D.24221;
      D.24250 = create_unhandled_exception_eventargs (exc);
      pa[1] = D.24250;
      mono_runtime_delegate_invoke (delegate, &pa, &e);
      if (domain != current_domain) goto <D.24251>; else goto <D.24252>;
      <D.24251>:
      mono_domain_set_internal_with_options (current_domain, 0);
      <D.24252>:
      e.126 = e;
      if (e.126 != 0B) goto <D.24254>; else goto <D.24255>;
      <D.24254>:
      {
        struct MonoError error;
        gchar * msg;

        try
          {
            e.126 = e;
            D.24256 = MEM[(struct MonoException *)e.126].message;
            msg = mono_string_to_utf8_checked (D.24256, &error);
            D.24257 = mono_error_ok (&error);
            if (D.24257 == 0) goto <D.24258>; else goto <D.24259>;
            <D.24258>:
            monoeg_g_log (0B, 16, "Exception inside UnhandledException handler with invalid message (Invalid characters)\n");
            mono_error_cleanup (&error);
            goto <D.24260>;
            <D.24259>:
            monoeg_g_log (0B, 16, "exception inside UnhandledException handler: %s\n", msg);
            monoeg_g_free (msg);
            <D.24260>:
          }
        finally
          {
            error = {CLOBBER};
          }
      }
      <D.24255>:
    }
  finally
    {
      e = {CLOBBER};
      pa = {CLOBBER};
    }
}


create_unhandled_exception_eventargs (struct MonoObject * exc)
{
  struct MonoImage * D.24261;
  _Bool D.24262;
  long int D.24263;
  long int D.24264;
  _Bool D.24267;
  long int D.24268;
  long int D.24269;
  struct MonoDomain * D.24272;
  struct MonoObject * D.24273;
  struct MonoClass * klass;
  void * args[2];
  struct MonoMethod * method;
  MonoBoolean is_terminating;
  struct MonoObject * obj;

  try
    {
      method = 0B;
      is_terminating = 1;
      D.24261 = mono_defaults.corlib;
      klass = mono_class_from_name (D.24261, "System", "UnhandledExceptionEventArgs");
      D.24262 = klass == 0B;
      D.24263 = (long int) D.24262;
      D.24264 = __builtin_expect (D.24263, 0);
      if (D.24264 != 0) goto <D.24265>; else goto <D.24266>;
      <D.24265>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 3823, "klass");
      <D.24266>:
      mono_class_init (klass);
      method = mono_class_get_method_from_name_flags (klass, ".ctor", 2, 6);
      D.24267 = method == 0B;
      D.24268 = (long int) D.24267;
      D.24269 = __builtin_expect (D.24268, 0);
      if (D.24269 != 0) goto <D.24270>; else goto <D.24271>;
      <D.24270>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 3829, "method");
      <D.24271>:
      args[0] = exc;
      args[1] = &is_terminating;
      D.24272 = mono_domain_get ();
      obj = mono_object_new (D.24272, klass);
      mono_runtime_invoke (method, obj, &args, 0B);
      D.24273 = obj;
      return D.24273;
    }
  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.24276;
  long int D.24277;
  long int D.24278;
  struct MonoVTable * D.24281;
  struct MonoAssembly * D.24282;
  struct MonoClass * D.24285;
  struct MonoImage * D.24286;
  struct MonoAppDomainSetup * D.24287;
  struct MonoString * D.24288;
  struct MonoString * * D.24291;
  char * D.24292;
  struct MonoString * D.24293;
  struct MonoString * D.24294;
  struct MonoImage * D.24297;
  char * D.24298;
  struct MonoString * * D.24299;
  struct MonoString * D.24300;
  struct MonoClass * stathread_attribute.127;
  struct MonoImage * D.24306;
  struct MonoClass * stathread_attribute.128;
  int D.24308;
  struct MonoMethodSignature * D.24315;
  struct MonoType * D.24316;
  unsigned char D.24317;
  struct MonoObject * D.24324;
  guint32 * D.24325;
  unsigned int D.24326;
  int D.24332;
  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.24276 = args == 0B;
      D.24277 = (long int) D.24276;
      D.24278 = __builtin_expect (D.24277, 0);
      if (D.24278 != 0) goto <D.24279>; else goto <D.24280>;
      <D.24279>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 4008, "args");
      <D.24280>:
      pa[0] = args;
      D.24281 = MEM[(struct MonoObject *)args].vtable;
      domain = D.24281->domain;
      D.24282 = domain->entry_assembly;
      if (D.24282 == 0B) goto <D.24283>; else goto <D.24284>;
      <D.24283>:
      {
        gchar * str;
        struct MonoAssembly * assembly;

        D.24285 = method->klass;
        D.24286 = D.24285->image;
        assembly = D.24286->assembly;
        domain->entry_assembly = assembly;
        D.24287 = domain->setup;
        D.24288 = D.24287->application_base;
        if (D.24288 == 0B) goto <D.24289>; else goto <D.24290>;
        <D.24289>:
        D.24287 = domain->setup;
        D.24287 = domain->setup;
        D.24291 = &D.24287->application_base;
        D.24292 = assembly->basedir;
        D.24293 = mono_string_new (domain, D.24292);
        mono_gc_wbarrier_set_field (D.24287, D.24291, D.24293);
        <D.24290>:
        D.24287 = domain->setup;
        D.24294 = D.24287->configuration_file;
        if (D.24294 == 0B) goto <D.24295>; else goto <D.24296>;
        <D.24295>:
        D.24297 = assembly->image;
        D.24298 = D.24297->name;
        str = monoeg_g_strconcat (D.24298, ".config", 0B);
        D.24287 = domain->setup;
        D.24287 = domain->setup;
        D.24299 = &D.24287->configuration_file;
        D.24300 = mono_string_new (domain, str);
        mono_gc_wbarrier_set_field (D.24287, D.24299, D.24300);
        monoeg_g_free (str);
        mono_set_private_bin_path_from_config (domain);
        <D.24296>:
      }
      <D.24284>:
      cinfo = mono_custom_attrs_from_method (method);
      if (cinfo != 0B) goto <D.24301>; else goto <D.24302>;
      <D.24301>:
      {
        static struct MonoClass * stathread_attribute = 0B;

        stathread_attribute.127 = stathread_attribute;
        if (stathread_attribute.127 == 0B) goto <D.24304>; else goto <D.24305>;
        <D.24304>:
        D.24306 = mono_defaults.corlib;
        stathread_attribute.128 = mono_class_from_name (D.24306, "System", "STAThreadAttribute");
        stathread_attribute = stathread_attribute.128;
        <D.24305>:
        stathread_attribute.127 = stathread_attribute;
        has_stathread_attribute = mono_custom_attrs_has_attr (cinfo, stathread_attribute.127);
        D.24308 = cinfo->cached;
        if (D.24308 == 0) goto <D.24309>; else goto <D.24310>;
        <D.24309>:
        mono_custom_attrs_free (cinfo);
        <D.24310>:
      }
      goto <D.24311>;
      <D.24302>:
      has_stathread_attribute = 0;
      <D.24311>:
      if (has_stathread_attribute != 0) goto <D.24312>; else goto <D.24313>;
      <D.24312>:
      thread->apartment_state = 0;
      goto <D.24314>;
      <D.24313>:
      thread->apartment_state = 1;
      <D.24314>:
      mono_thread_init_apartment_state ();
      D.24315 = mono_method_signature (method);
      D.24316 = D.24315->ret;
      D.24317 = D.24316->type;
      if (D.24317 == 8) goto <D.24318>; else goto <D.24319>;
      <D.24318>:
      {
        struct MonoObject * res;

        res = mono_runtime_invoke (method, 0B, &pa, exc);
        if (exc == 0B) goto <D.24320>; else goto <D.24323>;
        <D.24323>:
        D.24324 = *exc;
        if (D.24324 == 0B) goto <D.24320>; else goto <D.24321>;
        <D.24320>:
        D.24325 = res + 16;
        D.24326 = *D.24325;
        rval = (int) D.24326;
        goto <D.24322>;
        <D.24321>:
        rval = -1;
        <D.24322>:
        mono_environment_exitcode_set (rval);
      }
      goto <D.24327>;
      <D.24319>:
      mono_runtime_invoke (method, 0B, &pa, exc);
      if (exc == 0B) goto <D.24328>; else goto <D.24331>;
      <D.24331>:
      D.24324 = *exc;
      if (D.24324 == 0B) goto <D.24328>; else goto <D.24329>;
      <D.24328>:
      rval = 0;
      goto <D.24330>;
      <D.24329>:
      rval = -1;
      mono_environment_exitcode_set (rval);
      <D.24330>:
      <D.24327>:
      D.24332 = rval;
      return D.24332;
    }
  finally
    {
      pa = {CLOBBER};
    }
}


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

  if (func != 0B) goto <D.24336>; else goto <D.24337>;
  <D.24336>:
  iftmp.129 = func;
  goto <D.24338>;
  <D.24337>:
  iftmp.129 = dummy_mono_runtime_invoke;
  <D.24338>:
  default_mono_runtime_invoke = iftmp.129;
}


mono_runtime_invoke_array (struct MonoMethod * method, void * obj, struct MonoArray * params, struct MonoObject * * exc)
{
  long unsigned int D.24341;
  long unsigned int D.24342;
  unsigned char D.24343;
  int D.24344;
  struct MonoType * D.24348;
  struct MonoClass * D.24349;
  int D.24350;
  long unsigned int D.24352;
  long unsigned int D.24353;
  void * * D.24354;
  long unsigned int D.24355;
  char * D.24356;
  struct MonoObject * D.24357;
  long unsigned int D.24358;
  long unsigned int D.24359;
  char * D.24362;
  struct MonoObject * D.24363;
  struct MonoDomain * D.24366;
  struct MonoClass * D.24367;
  struct MonoObject * D.24368;
  char * D.24371;
  struct MonoDomain * D.24372;
  struct MonoVTable * D.24373;
  struct MonoClass * D.24374;
  void * D.24375;
  char * D.24376;
  struct MonoObject * D.24377;
  void * D.24378;
  char * D.24381;
  char * D.24383;
  struct MonoObject * D.24384;
  struct MonoGenericClass * D.24387;
  struct MonoClass * D.24388;
  char * D.24390;
  struct MonoVTable * D.24394;
  struct MonoClass * D.24395;
  struct MonoClass * D.24396;
  _Bool D.24397;
  long int D.24398;
  long int D.24399;
  void * D.24402;
  unsigned char D.24403;
  int D.24404;
  long unsigned int D.24405;
  int D.20689;
  int iftmp.130;
  int D.20688;
  const char[6] * D.24410;
  unsigned char D.24411;
  int D.24412;
  unsigned char D.24413;
  int D.24414;
  const unsigned char * D.24419;
  unsigned char D.24420;
  int D.24421;
  const unsigned char * D.24422;
  unsigned char D.24423;
  int D.24424;
  const unsigned char * D.24429;
  unsigned char D.24430;
  int D.24431;
  const unsigned char * D.24432;
  unsigned char D.24433;
  int D.24434;
  const unsigned char * D.24439;
  unsigned char D.24440;
  int D.24441;
  const unsigned char * D.24442;
  unsigned char D.24443;
  int D.24444;
  const char * D.24446;
  struct MonoClass * D.24448;
  struct MonoClass * D.24449;
  int D.24451;
  _Bool D.24454;
  long int D.24455;
  long int D.24456;
  struct MonoObject * D.24461;
  struct MonoDomain * D.24462;
  struct MonoClass * D.24463;
  void * D.24464;
  struct MonoDomain * D.24467;
  _Bool D.24468;
  long int D.24469;
  long int D.24470;
  struct MonoVTable * D.24473;
  struct MonoClass * D.24474;
  struct MonoClass * D.24475;
  struct MonoMethod * iftmp.131;
  short int D.24479;
  struct MonoMethod * * D.24482;
  long unsigned int D.24483;
  long unsigned int D.24484;
  struct MonoMethod * * D.24485;
  long unsigned int D.24487;
  long unsigned int D.24488;
  struct MonoDomain * D.24495;
  int D.24496;
  struct MonoDomain * D.24499;
  void * D.24500;
  struct MonoDomain * D.24501;
  struct MonoObject * D.24502;
  struct MonoType * D.24503;
  unsigned char D.24504;
  struct MonoClass * pointer_class.134;
  struct MonoClass * tmp_klass.132;
  struct MonoImage * D.24512;
  struct MonoClass * tmp_klass.133;
  _Bool D.24514;
  long int D.24515;
  long int D.24516;
  struct MonoMethod * box_method.135;
  struct MonoMethod * box_method.136;
  struct MonoVTable * D.24523;
  struct MonoClass * D.24524;
  _Bool D.24525;
  long int D.24526;
  long int D.24527;
  void * D.24530;
  struct MonoDomain * D.24531;
  struct MonoReflectionType * D.24532;
  struct MonoObject * box_exc.137;
  _Bool D.24534;
  long int D.24535;
  long int D.24536;
  long unsigned int D.24541;
  long unsigned int D.24542;
  struct MonoClass * D.24545;
  int D.24546;
  void * D.24549;
  long unsigned int D.24550;
  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.24339>; else goto <D.24340>;
  <D.24339>:
  D.24341 = mono_array_length (params);
  D.24342 = D.24341 * 8;
  pa = __builtin_alloca (D.24342);
  i = 0;
  goto <D.20679>;
  <D.20678>:
  {
    struct MonoType * t;

    t = sig->params[i];
    again:
    D.24343 = t->type;
    D.24344 = (int) D.24343;
    switch (D.24344) <default: <D.20676>, case 2: <D.20650>, case 3: <D.20653>, case 4: <D.20649>, case 5: <D.20648>, case 6: <D.20652>, case 7: <D.20651>, case 8: <D.20657>, case 9: <D.20656>, case 10: <D.20659>, case 11: <D.20658>, case 12: <D.20660>, case 13: <D.20661>, case 14: <D.20668>, case 15: <D.20674>, case 17: <D.20662>, case 18: <D.20670>, case 20: <D.20671>, case 21: <D.20673>, case 24: <D.20655>, case 25: <D.20654>, case 28: <D.20669>, case 29: <D.20672>>
    <D.20648>:
    <D.20649>:
    <D.20650>:
    <D.20651>:
    <D.20652>:
    <D.20653>:
    <D.20654>:
    <D.20655>:
    <D.20656>:
    <D.20657>:
    <D.20658>:
    <D.20659>:
    <D.20660>:
    <D.20661>:
    <D.20662>:
    D.24343 = t->type;
    if (D.24343 == 17) goto <D.24347>; else goto <D.24345>;
    <D.24347>:
    D.24348 = sig->params[i];
    D.24349 = mono_class_from_mono_type (D.24348);
    D.24350 = mono_class_is_nullable (D.24349);
    if (D.24350 != 0) goto <D.24351>; else goto <D.24345>;
    <D.24351>:
    D.24352 = (long unsigned int) i;
    D.24353 = D.24352 * 8;
    D.24354 = pa + D.24353;
    D.24355 = (long unsigned int) i;
    D.24356 = mono_array_addr_with_size (params, 8, D.24355);
    D.24357 = MEM[(struct MonoObject * *)D.24356];
    *D.24354 = D.24357;
    D.24358 = BIT_FIELD_REF <*t, 64, 64>;
    D.24359 = D.24358 & 1073741824;
    if (D.24359 != 0) goto <D.24360>; else goto <D.24361>;
    <D.24360>:
    has_byref_nullables = 1;
    <D.24361>:
    goto <D.24346>;
    <D.24345>:
    D.24355 = (long unsigned int) i;
    D.24362 = mono_array_addr_with_size (params, 8, D.24355);
    D.24363 = MEM[(struct MonoObject * *)D.24362];
    if (D.24363 == 0B) goto <D.24364>; else goto <D.24365>;
    <D.24364>:
    {
      void * * __p;

      D.24355 = (long unsigned int) i;
      __p = mono_array_addr_with_size (params, 8, D.24355);
      D.24366 = mono_domain_get ();
      D.24348 = sig->params[i];
      D.24367 = mono_class_from_mono_type (D.24348);
      D.24368 = mono_object_new (D.24366, D.24367);
      mono_gc_wbarrier_set_arrayref (params, __p, D.24368);
    }
    <D.24365>:
    D.24358 = BIT_FIELD_REF <*t, 64, 64>;
    D.24359 = D.24358 & 1073741824;
    if (D.24359 != 0) goto <D.24369>; else goto <D.24370>;
    <D.24369>:
    {
      struct MonoObject * orig;
      struct MonoObject * copy;

      D.24355 = (long unsigned int) i;
      D.24371 = mono_array_addr_with_size (params, 8, D.24355);
      orig = MEM[(struct MonoObject * *)D.24371];
      D.24372 = mono_domain_get ();
      D.24373 = orig->vtable;
      D.24374 = D.24373->klass;
      D.24375 = mono_object_unbox (orig);
      copy = mono_value_box (D.24372, D.24374, D.24375);
      {
        void * * __p;

        D.24355 = (long unsigned int) i;
        __p = mono_array_addr_with_size (params, 8, D.24355);
        mono_gc_wbarrier_set_arrayref (params, __p, copy);
      }
    }
    <D.24370>:
    D.24352 = (long unsigned int) i;
    D.24353 = D.24352 * 8;
    D.24354 = pa + D.24353;
    D.24355 = (long unsigned int) i;
    D.24376 = mono_array_addr_with_size (params, 8, D.24355);
    D.24377 = MEM[(struct MonoObject * *)D.24376];
    D.24378 = mono_object_unbox (D.24377);
    *D.24354 = D.24378;
    <D.24346>:
    goto <D.20667>;
    <D.20668>:
    <D.20669>:
    <D.20670>:
    <D.20671>:
    <D.20672>:
    D.24358 = BIT_FIELD_REF <*t, 64, 64>;
    D.24359 = D.24358 & 1073741824;
    if (D.24359 != 0) goto <D.24379>; else goto <D.24380>;
    <D.24379>:
    D.24352 = (long unsigned int) i;
    D.24353 = D.24352 * 8;
    D.24354 = pa + D.24353;
    D.24355 = (long unsigned int) i;
    D.24381 = mono_array_addr_with_size (params, 8, D.24355);
    *D.24354 = D.24381;
    goto <D.24382>;
    <D.24380>:
    D.24352 = (long unsigned int) i;
    D.24353 = D.24352 * 8;
    D.24354 = pa + D.24353;
    D.24355 = (long unsigned int) i;
    D.24383 = mono_array_addr_with_size (params, 8, D.24355);
    D.24384 = MEM[(struct MonoObject * *)D.24383];
    *D.24354 = D.24384;
    <D.24382>:
    goto <D.20667>;
    <D.20673>:
    D.24358 = BIT_FIELD_REF <*t, 64, 64>;
    D.24359 = D.24358 & 1073741824;
    if (D.24359 != 0) goto <D.24385>; else goto <D.24386>;
    <D.24385>:
    D.24387 = t->data.generic_class;
    D.24388 = D.24387->container_class;
    t = &D.24388->this_arg;
    goto <D.24389>;
    <D.24386>:
    D.24387 = t->data.generic_class;
    D.24388 = D.24387->container_class;
    t = &D.24388->byval_arg;
    <D.24389>:
    goto again;
    <D.20674>:
    {
      struct MonoObject * arg;

      D.24355 = (long unsigned int) i;
      D.24390 = mono_array_addr_with_size (params, 8, D.24355);
      arg = MEM[(struct MonoObject * *)D.24390];
      if (arg == 0B) goto <D.24391>; else goto <D.24392>;
      <D.24391>:
      D.24352 = (long unsigned int) i;
      D.24353 = D.24352 * 8;
      D.24354 = pa + D.24353;
      *D.24354 = 0B;
      goto <D.24393>;
      <D.24392>:
      D.24394 = arg->vtable;
      D.24395 = D.24394->klass;
      D.24396 = mono_defaults.int_class;
      D.24397 = D.24395 != D.24396;
      D.24398 = (long int) D.24397;
      D.24399 = __builtin_expect (D.24398, 0);
      if (D.24399 != 0) goto <D.24400>; else goto <D.24401>;
      <D.24400>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 4211, "arg->vtable->klass == mono_defaults.int_class");
      <D.24401>:
      D.24352 = (long unsigned int) i;
      D.24353 = D.24352 * 8;
      D.24354 = pa + D.24353;
      D.24402 = MEM[(struct MonoIntPtr *)arg].m_value;
      *D.24354 = D.24402;
      <D.24393>:
      goto <D.20667>;
    }
    <D.20676>:
    D.24348 = sig->params[i];
    D.24403 = D.24348->type;
    D.24404 = (int) D.24403;
    monoeg_g_log (0B, 4, "type 0x%x not handled in mono_runtime_invoke_array", D.24404);
    <D.20677>:
    goto <D.20677>;
    <D.20667>:
  }
  i = i + 1;
  <D.20679>:
  D.24355 = (long unsigned int) i;
  D.24405 = mono_array_length (params);
  if (D.24355 < D.24405) goto <D.20678>; else goto <D.20680>;
  <D.20680>:
  <D.24340>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = method->name;
      D.24410 = ".ctor";
      D.24411 = MEM[(const unsigned char *)D.24410];
      D.24412 = (int) D.24411;
      D.24413 = *__s2;
      D.24414 = (int) D.24413;
      __result = D.24412 - D.24414;
      {
        if (__s2_len != 0) goto <D.24415>; else goto <D.24416>;
        <D.24415>:
        if (__result == 0) goto <D.24417>; else goto <D.24418>;
        <D.24417>:
        D.24419 = &MEM[(void *)".ctor" + 1B];
        D.24420 = *D.24419;
        D.24421 = (int) D.24420;
        D.24422 = __s2 + 1;
        D.24423 = *D.24422;
        D.24424 = (int) D.24423;
        __result = D.24421 - D.24424;
        if (__s2_len > 1) goto <D.24425>; else goto <D.24426>;
        <D.24425>:
        if (__result == 0) goto <D.24427>; else goto <D.24428>;
        <D.24427>:
        D.24429 = &MEM[(void *)".ctor" + 2B];
        D.24430 = *D.24429;
        D.24431 = (int) D.24430;
        D.24432 = __s2 + 2;
        D.24433 = *D.24432;
        D.24434 = (int) D.24433;
        __result = D.24431 - D.24434;
        if (__s2_len > 2) goto <D.24435>; else goto <D.24436>;
        <D.24435>:
        if (__result == 0) goto <D.24437>; else goto <D.24438>;
        <D.24437>:
        D.24439 = &MEM[(void *)".ctor" + 3B];
        D.24440 = *D.24439;
        D.24441 = (int) D.24440;
        D.24442 = __s2 + 3;
        D.24443 = *D.24442;
        D.24444 = (int) D.24443;
        __result = D.24441 - D.24444;
        <D.24438>:
        <D.24436>:
        <D.24428>:
        <D.24426>:
        <D.24418>:
        <D.24416>:
      }
      D.20688 = __result;
    }
    iftmp.130 = -D.20688;
    goto <D.24445>;
    <D.24409>:
    D.24446 = method->name;
    iftmp.130 = __builtin_strcmp (D.24446, ".ctor");
    <D.24445>:
    D.20689 = iftmp.130;
  }
  if (D.20689 == 0) goto <D.24447>; else goto <D.24406>;
  <D.24447>:
  D.24448 = method->klass;
  D.24449 = mono_defaults.string_class;
  if (D.24448 != D.24449) goto <D.24450>; else goto <D.24406>;
  <D.24450>:
  {
    void * o;

    o = obj;
    D.24448 = method->klass;
    D.24451 = mono_class_is_nullable (D.24448);
    if (D.24451 != 0) goto <D.24452>; else goto <D.24453>;
    <D.24452>:
    D.24454 = obj != 0B;
    D.24455 = (long int) D.24454;
    D.24456 = __builtin_expect (D.24455, 0);
    if (D.24456 != 0) goto <D.24457>; else goto <D.24458>;
    <D.24457>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 4227, "!obj");
    <D.24458>:
    if (params == 0B) goto <D.24459>; else goto <D.24460>;
    <D.24459>:
    D.24461 = 0B;
    return D.24461;
    <D.24460>:
    D.24462 = mono_domain_get ();
    D.24448 = method->klass;
    D.24463 = D.24448->cast_class;
    D.24464 = *pa;
    D.24461 = mono_value_box (D.24462, D.24463, D.24464);
    return D.24461;
    <D.24453>:
    if (obj == 0B) goto <D.24465>; else goto <D.24466>;
    <D.24465>:
    D.24467 = mono_domain_get ();
    D.24448 = method->klass;
    obj = mono_object_new (D.24467, D.24448);
    D.24468 = obj == 0B;
    D.24469 = (long int) D.24468;
    D.24470 = __builtin_expect (D.24469, 0);
    if (D.24470 != 0) goto <D.24471>; else goto <D.24472>;
    <D.24471>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 4237, "obj");
    <D.24472>:
    D.24473 = MEM[(struct MonoObject *)obj].vtable;
    D.24474 = D.24473->klass;
    D.24475 = mono_defaults.transparent_proxy_class;
    if (D.24474 == D.24475) goto <D.24476>; else goto <D.24477>;
    <D.24476>:
    D.24479 = method->slot;
    if (D.24479 != -1) goto <D.24480>; else goto <D.24481>;
    <D.24480>:
    D.24448 = method->klass;
    D.24482 = D.24448->vtable;
    D.24479 = method->slot;
    D.24483 = (long unsigned int) D.24479;
    D.24484 = D.24483 * 8;
    D.24485 = D.24482 + D.24484;
    iftmp.131 = *D.24485;
    goto <D.24486>;
    <D.24481>:
    iftmp.131 = method;
    <D.24486>:
    method = mono_marshal_get_remoting_invoke (iftmp.131);
    <D.24477>:
    D.24448 = method->klass;
    D.24487 = BIT_FIELD_REF <*D.24448, 64, 256>;
    D.24488 = D.24487 & 8;
    if (D.24488 != 0) goto <D.24489>; else goto <D.24490>;
    <D.24489>:
    o = mono_object_unbox (obj);
    goto <D.24491>;
    <D.24490>:
    o = obj;
    <D.24491>:
    goto <D.24492>;
    <D.24466>:
    D.24448 = method->klass;
    D.24487 = BIT_FIELD_REF <*D.24448, 64, 256>;
    D.24488 = D.24487 & 8;
    if (D.24488 != 0) goto <D.24493>; else goto <D.24494>;
    <D.24493>:
    D.24495 = mono_domain_get ();
    D.24448 = method->klass;
    obj = mono_value_box (D.24495, D.24448, obj);
    <D.24494>:
    <D.24492>:
    mono_runtime_invoke (method, o, pa, exc);
    D.24461 = obj;
    return D.24461;
  }
  <D.24406>:
  D.24448 = method->klass;
  D.24496 = mono_class_is_nullable (D.24448);
  if (D.24496 != 0) goto <D.24497>; else goto <D.24498>;
  <D.24497>:
  {
    struct MonoObject * nullable;

    D.24499 = mono_domain_get ();
    D.24448 = method->klass;
    nullable = mono_object_new (D.24499, D.24448);
    D.24500 = mono_object_unbox (nullable);
    D.24501 = mono_domain_get ();
    D.24448 = method->klass;
    D.24463 = D.24448->cast_class;
    D.24502 = mono_value_box (D.24501, D.24463, obj);
    D.24448 = method->klass;
    mono_nullable_init (D.24500, D.24502, D.24448);
    obj = mono_object_unbox (nullable);
  }
  <D.24498>:
  res = mono_runtime_invoke (method, obj, pa, exc);
  D.24503 = sig->ret;
  D.24504 = D.24503->type;
  if (D.24504 == 15) goto <D.24505>; else goto <D.24506>;
  <D.24505>:
  {
    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.132 = tmp_klass;
            if (tmp_klass.132 == 0B) goto <D.24508>; else goto <D.24509>;
            <D.24508>:
            if (0 != 0) goto <D.24510>; else goto <D.24511>;
            <D.24510>:
            monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 4277, "mono_defaults.corlib == mono_defaults.corlib");
            <D.24511>:
            D.24512 = mono_defaults.corlib;
            tmp_klass.133 = mono_class_from_name (D.24512, "System.Reflection", "Pointer");
            tmp_klass = tmp_klass.133;
            tmp_klass.132 = tmp_klass;
            D.24514 = tmp_klass.132 == 0B;
            D.24515 = (long int) D.24514;
            D.24516 = __builtin_expect (D.24515, 0);
            if (D.24516 != 0) goto <D.24517>; else goto <D.24518>;
            <D.24517>:
            monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 4277, "tmp_klass");
            <D.24518>:
            <D.24509>:
          }
          pointer_class.134 = tmp_klass;
        }
        pointer_class = pointer_class.134;
        box_method.135 = box_method;
        if (box_method.135 == 0B) goto <D.24520>; else goto <D.24521>;
        <D.24520>:
        box_method.136 = mono_class_get_method_from_name (pointer_class, "Box", -1);
        box_method = box_method.136;
        <D.24521>:
        D.24523 = res->vtable;
        D.24524 = D.24523->klass;
        D.24396 = mono_defaults.int_class;
        D.24525 = D.24524 != D.24396;
        D.24526 = (long int) D.24525;
        D.24527 = __builtin_expect (D.24526, 0);
        if (D.24527 != 0) goto <D.24528>; else goto <D.24529>;
        <D.24528>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 4281, "res->vtable->klass == mono_defaults.int_class");
        <D.24529>:
        D.24530 = MEM[(struct MonoIntPtr *)res].m_value;
        box_args[0] = D.24530;
        D.24531 = mono_domain_get ();
        D.24503 = sig->ret;
        D.24532 = mono_type_get_object (D.24531, D.24503);
        box_args[1] = D.24532;
        box_method.135 = box_method;
        res = mono_runtime_invoke (box_method.135, 0B, &box_args, &box_exc);
        box_exc.137 = box_exc;
        D.24534 = box_exc.137 != 0B;
        D.24535 = (long int) D.24534;
        D.24536 = __builtin_expect (D.24535, 0);
        if (D.24536 != 0) goto <D.24537>; else goto <D.24538>;
        <D.24537>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 4285, "!box_exc");
        <D.24538>:
      }
    finally
      {
        box_args = {CLOBBER};
        box_exc = {CLOBBER};
      }
  }
  <D.24506>:
  if (has_byref_nullables != 0) goto <D.24539>; else goto <D.24540>;
  <D.24539>:
  i = 0;
  goto <D.20701>;
  <D.20700>:
  {
    struct MonoType * t;

    t = sig->params[i];
    D.24541 = BIT_FIELD_REF <*t, 64, 64>;
    D.24542 = D.24541 & 1090453504;
    if (D.24542 == 1075118080) goto <D.24543>; else goto <D.24544>;
    <D.24543>:
    D.24545 = mono_class_from_mono_type (t);
    D.24546 = mono_class_is_nullable (D.24545);
    if (D.24546 != 0) goto <D.24547>; else goto <D.24548>;
    <D.24547>:
    {
      void * * __p;

      D.24355 = (long unsigned int) i;
      __p = mono_array_addr_with_size (params, 8, D.24355);
      D.24352 = (long unsigned int) i;
      D.24353 = D.24352 * 8;
      D.24354 = pa + D.24353;
      D.24549 = *D.24354;
      mono_gc_wbarrier_set_arrayref (params, __p, D.24549);
    }
    <D.24548>:
    <D.24544>:
  }
  i = i + 1;
  <D.20701>:
  D.24355 = (long unsigned int) i;
  D.24550 = mono_array_length (params);
  if (D.24355 < D.24550) goto <D.20700>; else goto <D.20702>;
  <D.20702>:
  <D.24540>:
  D.24461 = res;
  return D.24461;
}


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

  vtable = mono_class_vtable (domain, klass);
  if (vtable == 0B) goto <D.24552>; else goto <D.24553>;
  <D.24552>:
  D.24554 = 0B;
  return D.24554;
  <D.24553>:
  D.24554 = mono_object_new_specific (vtable);
  return D.24554;
}


mono_object_new_pinned (struct MonoDomain * domain, struct MonoClass * klass)
{
  struct MonoObject * D.24558;
  int D.24559;
  long unsigned int D.24560;
  struct MonoVTable * vtable;

  vtable = mono_class_vtable (domain, klass);
  if (vtable == 0B) goto <D.24556>; else goto <D.24557>;
  <D.24556>:
  D.24558 = 0B;
  return D.24558;
  <D.24557>:
  D.24559 = mono_class_instance_size (klass);
  D.24560 = (long unsigned int) D.24559;
  D.24558 = mono_gc_alloc_pinned_obj (vtable, D.24560);
  return D.24558;
}


mono_object_new_specific (struct MonoVTable * vtable)
{
  long unsigned int D.24564;
  long unsigned int D.24565;
  struct MonoClass * D.24567;
  long unsigned int D.24568;
  long unsigned int D.24569;
  struct MonoDomain * D.24570;
  struct MonoImage * D.24573;
  long unsigned int D.24574;
  long unsigned int D.24575;
  _Bool D.24578;
  long int D.24579;
  long int D.24580;
  struct MonoDomain * D.24583;
  struct MonoType * D.24584;
  struct MonoReflectionType * D.24585;
  struct MonoObject * D.24588;
  struct MonoObject * o;

  D.24564 = BIT_FIELD_REF <*vtable, 64, 320>;
  D.24565 = D.24564 & 16777216;
  if (D.24565 != 0) goto <D.24562>; else goto <D.24566>;
  <D.24566>:
  D.24567 = vtable->klass;
  D.24568 = BIT_FIELD_REF <*D.24567, 64, 256>;
  D.24569 = D.24568 & 1073741824;
  if (D.24569 != 0) goto <D.24562>; else goto <D.24563>;
  <D.24562>:
  {
    void * pa[1];
    struct MonoMethod * im;

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

          D.24573 = mono_defaults.corlib;
          klass = mono_class_from_name (D.24573, "System.Runtime.Remoting.Activation", "ActivationServices");
          D.24574 = BIT_FIELD_REF <*klass, 64, 256>;
          D.24575 = D.24574 & 1;
          if (D.24575 == 0) goto <D.24576>; else goto <D.24577>;
          <D.24576>:
          mono_class_init (klass);
          <D.24577>:
          im = mono_class_get_method_from_name (klass, "CreateProxyForType", 1);
          D.24578 = im == 0B;
          D.24579 = (long int) D.24578;
          D.24580 = __builtin_expect (D.24579, 0);
          if (D.24580 != 0) goto <D.24581>; else goto <D.24582>;
          <D.24581>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 4430, "im");
          <D.24582>:
          D.24570 = vtable->domain;
          D.24570->create_proxy_for_type_method = im;
        }
        <D.24572>:
        D.24583 = mono_domain_get ();
        D.24567 = vtable->klass;
        D.24584 = &D.24567->byval_arg;
        D.24585 = mono_type_get_object (D.24583, D.24584);
        pa[0] = D.24585;
        o = mono_runtime_invoke (im, 0B, &pa, 0B);
        if (o != 0B) goto <D.24586>; else goto <D.24587>;
        <D.24586>:
        D.24588 = o;
        return D.24588;
        <D.24587>:
      }
    finally
      {
        pa = {CLOBBER};
      }
  }
  <D.24563>:
  D.24588 = mono_object_new_alloc_specific (vtable);
  return D.24588;
}


mono_object_new_alloc_specific (struct MonoVTable * vtable)
{
  struct MonoClass * D.24592;
  long unsigned int D.24593;
  long unsigned int D.24594;
  void * D.24598;
  int D.24601;
  long unsigned int D.24602;
  long unsigned int D.24604;
  _Bool D.24605;
  long int D.24606;
  long int D.24607;
  int profile_allocs.138;
  _Bool D.24611;
  long int D.24612;
  long int D.24613;
  struct MonoObject * D.24616;
  struct MonoObject * o;

  D.24592 = vtable->klass;
  D.24593 = BIT_FIELD_REF <*D.24592, 64, 256>;
  D.24594 = D.24593 & 134217728;
  if (D.24594 == 0) goto <D.24595>; else goto <D.24596>;
  <D.24595>:
  o = mono_object_new_ptrfree (vtable);
  goto <D.24597>;
  <D.24596>:
  D.24598 = vtable->gc_descr;
  if (D.24598 != 0B) goto <D.24599>; else goto <D.24600>;
  <D.24599>:
  D.24592 = vtable->klass;
  D.24601 = D.24592->instance_size;
  D.24602 = (long unsigned int) D.24601;
  o = mono_object_allocate_spec (D.24602, vtable);
  goto <D.24603>;
  <D.24600>:
  D.24592 = vtable->klass;
  D.24601 = D.24592->instance_size;
  D.24602 = (long unsigned int) D.24601;
  o = mono_object_allocate (D.24602, vtable);
  <D.24603>:
  <D.24597>:
  D.24592 = vtable->klass;
  D.24593 = BIT_FIELD_REF <*D.24592, 64, 256>;
  D.24604 = D.24593 & 2097152;
  D.24605 = D.24604 != 0;
  D.24606 = (long int) D.24605;
  D.24607 = __builtin_expect (D.24606, 0);
  if (D.24607 != 0) goto <D.24608>; else goto <D.24609>;
  <D.24608>:
  mono_object_register_finalizer (o);
  <D.24609>:
  profile_allocs.138 = profile_allocs;
  D.24611 = profile_allocs.138 != 0;
  D.24612 = (long int) D.24611;
  D.24613 = __builtin_expect (D.24612, 0);
  if (D.24613 != 0) goto <D.24614>; else goto <D.24615>;
  <D.24614>:
  D.24592 = vtable->klass;
  mono_profiler_allocation (o, D.24592);
  <D.24615>:
  D.24616 = o;
  return D.24616;
}


mono_object_allocate_spec (size_t size, struct MonoVTable * vtable)
{
  long unsigned int D.24618;
  long unsigned int D.24619;
  void * D.24620;
  void * o;

  o = mono_gc_alloc_obj (vtable, size);
  D.24618 = mono_stats.new_object_count;
  D.24619 = D.24618 + 1;
  mono_stats.new_object_count = D.24619;
  D.24620 = o;
  return D.24620;
}


mono_object_allocate (size_t size, struct MonoVTable * vtable)
{
  long unsigned int D.24622;
  long unsigned int D.24623;
  void * D.24624;
  struct MonoObject * o;

  D.24622 = mono_stats.new_object_count;
  D.24623 = D.24622 + 1;
  mono_stats.new_object_count = D.24623;
  o = mono_gc_alloc_obj (vtable, size);
  D.24624 = o;
  return D.24624;
}


mono_object_new_fast (struct MonoVTable * vtable)
{
  struct MonoClass * D.24626;
  int D.24627;
  long unsigned int D.24628;
  struct MonoObject * D.24629;
  struct MonoObject * o;

  D.24626 = vtable->klass;
  D.24627 = D.24626->instance_size;
  D.24628 = (long unsigned int) D.24627;
  o = mono_gc_alloc_obj (vtable, D.24628);
  D.24629 = o;
  return D.24629;
}


mono_class_get_allocation_ftn (struct MonoVTable * vtable, gboolean for_box, gboolean * pass_size_in_words)
{
  <unnamed type> D.24631;
  unsigned int D.24632;
  struct MonoClass * D.24637;
  int D.24638;
  long unsigned int D.24640;
  long unsigned int D.24641;
  <unnamed type> D.24643;
  unsigned int D.24644;
  void * D.24645;
  long unsigned int D.24646;
  void * D.24651;

  *pass_size_in_words = 0;
  D.24631 = mono_profiler_get_events ();
  D.24632 = D.24631 & 128;
  if (D.24632 == 0) goto <D.24633>; else goto <D.24634>;
  <D.24633>:
  profile_allocs = 0;
  <D.24634>:
  D.24637 = vtable->klass;
  D.24638 = mono_class_has_finalizer (D.24637);
  if (D.24638 != 0) goto <D.24635>; else goto <D.24639>;
  <D.24639>:
  D.24637 = vtable->klass;
  D.24640 = BIT_FIELD_REF <*D.24637, 64, 256>;
  D.24641 = D.24640 & 4194304;
  if (D.24641 != 0) goto <D.24635>; else goto <D.24642>;
  <D.24642>:
  D.24643 = mono_profiler_get_events ();
  D.24644 = D.24643 & 128;
  if (D.24644 != 0) goto <D.24635>; else goto <D.24636>;
  <D.24635>:
  D.24645 = mono_object_new_specific;
  return D.24645;
  <D.24636>:
  D.24637 = vtable->klass;
  D.24640 = BIT_FIELD_REF <*D.24637, 64, 256>;
  D.24646 = D.24640 & 134217728;
  if (D.24646 == 0) goto <D.24647>; else goto <D.24648>;
  <D.24647>:
  if (for_box != 0) goto <D.24649>; else goto <D.24650>;
  <D.24649>:
  D.24645 = mono_object_new_ptrfree_box;
  return D.24645;
  <D.24650>:
  D.24645 = mono_object_new_ptrfree;
  return D.24645;
  <D.24648>:
  D.24651 = vtable->gc_descr;
  if (D.24651 != 0B) goto <D.24652>; else goto <D.24653>;
  <D.24652>:
  D.24645 = mono_object_new_fast;
  return D.24645;
  <D.24653>:
  D.24645 = mono_object_new_specific;
  return D.24645;
}


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

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


mono_object_clone (struct MonoObject * obj)
{
  struct MonoVTable * D.24657;
  struct MonoClass * D.24658;
  unsigned char D.24659;
  struct MonoObject * D.24662;
  long unsigned int D.24663;
  long unsigned int D.24664;
  long unsigned int D.24665;
  void * D.24669;
  const void * D.24670;
  long unsigned int D.24671;
  long unsigned int D.24672;
  int profile_allocs.139;
  _Bool D.24674;
  long int D.24675;
  long int D.24676;
  long unsigned int D.24679;
  struct MonoObject * o;
  int size;

  D.24657 = obj->vtable;
  D.24658 = D.24657->klass;
  size = D.24658->instance_size;
  D.24657 = obj->vtable;
  D.24658 = D.24657->klass;
  D.24659 = D.24658->rank;
  if (D.24659 != 0) goto <D.24660>; else goto <D.24661>;
  <D.24660>:
  D.24662 = mono_array_clone (obj);
  return D.24662;
  <D.24661>:
  D.24663 = (long unsigned int) size;
  D.24657 = obj->vtable;
  o = mono_object_allocate (D.24663, D.24657);
  D.24657 = obj->vtable;
  D.24658 = D.24657->klass;
  D.24664 = BIT_FIELD_REF <*D.24658, 64, 256>;
  D.24665 = D.24664 & 134217728;
  if (D.24665 != 0) goto <D.24666>; else goto <D.24667>;
  <D.24666>:
  mono_gc_wbarrier_object_copy (o, obj);
  goto <D.24668>;
  <D.24667>:
  {
    int size;

    D.24657 = obj->vtable;
    D.24658 = D.24657->klass;
    size = D.24658->instance_size;
    D.24669 = o + 16;
    D.24670 = obj + 16;
    D.24671 = (long unsigned int) size;
    D.24672 = D.24671 + 18446744073709551600;
    mono_gc_memmove_atomic (D.24669, D.24670, D.24672);
  }
  <D.24668>:
  profile_allocs.139 = profile_allocs;
  D.24674 = profile_allocs.139 != 0;
  D.24675 = (long int) D.24674;
  D.24676 = __builtin_expect (D.24675, 0);
  if (D.24676 != 0) goto <D.24677>; else goto <D.24678>;
  <D.24677>:
  D.24657 = obj->vtable;
  D.24658 = D.24657->klass;
  mono_profiler_allocation (o, D.24658);
  <D.24678>:
  D.24657 = obj->vtable;
  D.24658 = D.24657->klass;
  D.24664 = BIT_FIELD_REF <*D.24658, 64, 256>;
  D.24679 = D.24664 & 2097152;
  if (D.24679 != 0) goto <D.24680>; else goto <D.24681>;
  <D.24680>:
  mono_object_register_finalizer (o);
  <D.24681>:
  D.24662 = o;
  return D.24662;
}


mono_array_full_copy (struct MonoArray * src, struct MonoArray * dest)
{
  struct MonoVTable * D.24683;
  struct MonoVTable * D.24684;
  struct MonoClass * D.24685;
  _Bool D.24686;
  long int D.24687;
  long int D.24688;
  long unsigned int D.24691;
  _Bool D.24692;
  long int D.24693;
  long int D.24694;
  int D.24697;
  long unsigned int D.24698;
  struct MonoClass * D.24699;
  long unsigned int D.24700;
  long unsigned int D.24701;
  long unsigned int D.24704;
  double[0:] * D.24707;
  long unsigned int D.24708;
  int D.24709;
  double[0:] * D.24711;
  long unsigned int D.24713;
  int D.24714;
  uintptr_t size;
  struct MonoClass * klass;

  D.24683 = src->obj.vtable;
  klass = D.24683->klass;
  D.24684 = dest->obj.vtable;
  D.24685 = D.24684->klass;
  D.24686 = D.24685 != klass;
  D.24687 = (long int) D.24686;
  D.24688 = __builtin_expect (D.24687, 0);
  if (D.24688 != 0) goto <D.24689>; else goto <D.24690>;
  <D.24689>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 4619, "klass == dest->obj.vtable->klass");
  <D.24690>:
  size = mono_array_length (src);
  D.24691 = mono_array_length (dest);
  D.24692 = D.24691 != size;
  D.24693 = (long int) D.24692;
  D.24694 = __builtin_expect (D.24693, 0);
  if (D.24694 != 0) goto <D.24695>; else goto <D.24696>;
  <D.24695>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 4622, "size == mono_array_length (dest)");
  <D.24696>:
  D.24697 = mono_array_element_size (klass);
  D.24698 = (long unsigned int) D.24697;
  size = D.24698 * size;
  D.24699 = klass->element_class;
  D.24700 = BIT_FIELD_REF <*D.24699, 64, 256>;
  D.24701 = D.24700 & 8;
  if (D.24701 != 0) goto <D.24702>; else goto <D.24703>;
  <D.24702>:
  D.24699 = klass->element_class;
  D.24700 = BIT_FIELD_REF <*D.24699, 64, 256>;
  D.24704 = D.24700 & 134217728;
  if (D.24704 != 0) goto <D.24705>; else goto <D.24706>;
  <D.24705>:
  D.24707 = &src->vector;
  D.24708 = mono_array_length (src);
  D.24709 = (int) D.24708;
  mono_value_copy_array (dest, 0, D.24707, D.24709);
  goto <D.24710>;
  <D.24706>:
  D.24711 = &dest->vector;
  D.24707 = &src->vector;
  mono_gc_memmove_atomic (D.24711, D.24707, size);
  <D.24710>:
  goto <D.24712>;
  <D.24703>:
  {
    void * * __p;
    void * * __s;

    __p = mono_array_addr_with_size (dest, 8, 0);
    __s = mono_array_addr_with_size (src, 8, 0);
    D.24713 = mono_array_length (src);
    D.24714 = (int) D.24713;
    mono_gc_wbarrier_arrayref_copy (__p, __s, D.24714);
  }
  <D.24712>:
}


mono_array_clone_in_domain (struct MonoDomain * domain, struct MonoArray * array)
{
  struct MonoVTable * D.24715;
  struct MonoArrayBounds * D.24716;
  long unsigned int size.140;
  int D.24720;
  long unsigned int D.24721;
  long unsigned int size.141;
  long unsigned int size.142;
  struct MonoClass * D.24724;
  long unsigned int D.24725;
  long unsigned int D.24726;
  long unsigned int D.24729;
  double[0:] * D.24732;
  long unsigned int D.24733;
  int D.24734;
  double[0:] * D.24736;
  long unsigned int D.24738;
  int D.24739;
  struct MonoArray * D.24740;
  unsigned char D.24741;
  long unsigned int D.24742;
  long unsigned int D.24743;
  int D.24744;
  long unsigned int size.143;
  long unsigned int D.24746;
  uintptr_t * D.24747;
  struct MonoArrayBounds * D.24748;
  unsigned int D.24749;
  long unsigned int D.24750;
  long unsigned int size.144;
  long unsigned int D.24752;
  long unsigned int D.24753;
  long unsigned int D.24754;
  uintptr_t * D.24755;
  int D.24756;
  long unsigned int D.24757;
  long unsigned int D.24758;
  intptr_t * D.24759;
  long unsigned int D.24764;
  int D.24765;
  long unsigned int D.24768;
  int D.24769;
  struct MonoArray * o;
  uintptr_t size;
  uintptr_t i;
  uintptr_t * sizes;
  struct MonoClass * klass;

  try
    {
      D.24715 = array->obj.vtable;
      klass = D.24715->klass;
      D.24716 = array->bounds;
      if (D.24716 == 0B) goto <D.24717>; else goto <D.24718>;
      <D.24717>:
      size.140 = mono_array_length (array);
      size = size.140;
      o = mono_array_new_full (domain, klass, &size, 0B);
      D.24720 = mono_array_element_size (klass);
      D.24721 = (long unsigned int) D.24720;
      size.141 = size;
      size.142 = D.24721 * size.141;
      size = size.142;
      D.24724 = klass->element_class;
      D.24725 = BIT_FIELD_REF <*D.24724, 64, 256>;
      D.24726 = D.24725 & 8;
      if (D.24726 != 0) goto <D.24727>; else goto <D.24728>;
      <D.24727>:
      D.24724 = klass->element_class;
      D.24725 = BIT_FIELD_REF <*D.24724, 64, 256>;
      D.24729 = D.24725 & 134217728;
      if (D.24729 != 0) goto <D.24730>; else goto <D.24731>;
      <D.24730>:
      D.24732 = &array->vector;
      D.24733 = mono_array_length (array);
      D.24734 = (int) D.24733;
      mono_value_copy_array (o, 0, D.24732, D.24734);
      goto <D.24735>;
      <D.24731>:
      D.24736 = &o->vector;
      D.24732 = &array->vector;
      size.141 = size;
      mono_gc_memmove_atomic (D.24736, D.24732, size.141);
      <D.24735>:
      goto <D.24737>;
      <D.24728>:
      {
        void * * __p;
        void * * __s;

        __p = mono_array_addr_with_size (o, 8, 0);
        __s = mono_array_addr_with_size (array, 8, 0);
        D.24738 = mono_array_length (array);
        D.24739 = (int) D.24738;
        mono_gc_wbarrier_arrayref_copy (__p, __s, D.24739);
      }
      <D.24737>:
      D.24740 = o;
      return D.24740;
      <D.24718>:
      D.24741 = klass->rank;
      D.24742 = (long unsigned int) D.24741;
      D.24743 = D.24742 * 16;
      sizes = __builtin_alloca (D.24743);
      D.24744 = mono_array_element_size (klass);
      size.143 = (long unsigned int) D.24744;
      size = size.143;
      i = 0;
      goto <D.20791>;
      <D.20790>:
      D.24746 = i * 8;
      D.24747 = sizes + D.24746;
      D.24716 = array->bounds;
      D.24746 = i * 8;
      D.24748 = D.24716 + D.24746;
      D.24749 = D.24748->length;
      D.24750 = (long unsigned int) D.24749;
      *D.24747 = D.24750;
      D.24716 = array->bounds;
      D.24746 = i * 8;
      D.24748 = D.24716 + D.24746;
      D.24749 = D.24748->length;
      D.24750 = (long unsigned int) D.24749;
      size.141 = size;
      size.144 = D.24750 * size.141;
      size = size.144;
      D.24741 = klass->rank;
      D.24752 = (long unsigned int) D.24741;
      D.24753 = D.24752 + i;
      D.24754 = D.24753 * 8;
      D.24755 = sizes + D.24754;
      D.24716 = array->bounds;
      D.24746 = i * 8;
      D.24748 = D.24716 + D.24746;
      D.24756 = D.24748->lower_bound;
      D.24757 = (long unsigned int) D.24756;
      *D.24755 = D.24757;
      i = i + 1;
      <D.20791>:
      D.24741 = klass->rank;
      D.24752 = (long unsigned int) D.24741;
      if (D.24752 > i) goto <D.20790>; else goto <D.20792>;
      <D.20792>:
      D.24741 = klass->rank;
      D.24742 = (long unsigned int) D.24741;
      D.24758 = D.24742 * 8;
      D.24759 = sizes + D.24758;
      o = mono_array_new_full (domain, klass, sizes, D.24759);
      D.24724 = klass->element_class;
      D.24725 = BIT_FIELD_REF <*D.24724, 64, 256>;
      D.24726 = D.24725 & 8;
      if (D.24726 != 0) goto <D.24760>; else goto <D.24761>;
      <D.24760>:
      D.24724 = klass->element_class;
      D.24725 = BIT_FIELD_REF <*D.24724, 64, 256>;
      D.24729 = D.24725 & 134217728;
      if (D.24729 != 0) goto <D.24762>; else goto <D.24763>;
      <D.24762>:
      D.24732 = &array->vector;
      D.24764 = mono_array_length (array);
      D.24765 = (int) D.24764;
      mono_value_copy_array (o, 0, D.24732, D.24765);
      goto <D.24766>;
      <D.24763>:
      D.24736 = &o->vector;
      D.24732 = &array->vector;
      size.141 = size;
      mono_gc_memmove_atomic (D.24736, D.24732, size.141);
      <D.24766>:
      goto <D.24767>;
      <D.24761>:
      {
        void * * __p;
        void * * __s;

        __p = mono_array_addr_with_size (o, 8, 0);
        __s = mono_array_addr_with_size (array, 8, 0);
        D.24768 = mono_array_length (array);
        D.24769 = (int) D.24768;
        mono_gc_wbarrier_arrayref_copy (__p, __s, D.24769);
      }
      <D.24767>:
      D.24740 = o;
      return D.24740;
    }
  finally
    {
      size = {CLOBBER};
    }
}


mono_array_clone (struct MonoArray * array)
{
  struct MonoArray * D.24772;
  struct MonoVTable * D.24773;
  struct MonoDomain * D.24774;

  D.24773 = MEM[(struct MonoObject *)array].vtable;
  D.24774 = D.24773->domain;
  D.24772 = mono_array_clone_in_domain (D.24774, array);
  return D.24772;
}


mono_array_calc_byte_len (struct MonoClass * class, uintptr_t len, uintptr_t * res)
{
  int D.24776;
  int iftmp.145;
  unsigned int D.24780;
  unsigned int D.24782;
  unsigned int D.24784;
  _Bool D.24786;
  long int D.24787;
  long int D.24788;
  gboolean D.24791;
  _Bool D.24792;
  long int D.24793;
  long int D.24794;
  uintptr_t byte_len;

  D.24776 = mono_array_element_size (class);
  byte_len = (uintptr_t) D.24776;
  D.24780 = (unsigned int) byte_len;
  if (D.24780 != 0) goto <D.24781>; else goto <D.24778>;
  <D.24781>:
  D.24782 = (unsigned int) len;
  if (D.24782 != 0) goto <D.24783>; else goto <D.24778>;
  <D.24783>:
  D.24782 = (unsigned int) len;
  D.24780 = (unsigned int) byte_len;
  D.24784 = 4294967295 / D.24780;
  if (D.24782 > D.24784) goto <D.24785>; else goto <D.24778>;
  <D.24785>:
  iftmp.145 = 1;
  goto <D.24779>;
  <D.24778>:
  iftmp.145 = 0;
  <D.24779>:
  D.24786 = iftmp.145 != 0;
  D.24787 = (long int) D.24786;
  D.24788 = __builtin_expect (D.24787, 0);
  if (D.24788 != 0) goto <D.24789>; else goto <D.24790>;
  <D.24789>:
  D.24791 = 0;
  return D.24791;
  <D.24790>:
  byte_len = byte_len * len;
  D.24780 = (unsigned int) byte_len;
  D.24792 = D.24780 > 4294967263;
  D.24793 = (long int) D.24792;
  D.24794 = __builtin_expect (D.24793, 0);
  if (D.24794 != 0) goto <D.24795>; else goto <D.24796>;
  <D.24795>:
  D.24791 = 0;
  return D.24791;
  <D.24796>:
  byte_len = byte_len + 32;
  *res = byte_len;
  D.24791 = 1;
  return D.24791;
}


mono_array_new_full (struct MonoDomain * domain, struct MonoClass * array_class, uintptr_t * lengths, intptr_t * lower_bounds)
{
  long unsigned int D.24798;
  long unsigned int D.24799;
  unsigned char D.24804;
  unsigned char D.24806;
  long int D.24809;
  long unsigned int D.24812;
  long unsigned int D.24813;
  long unsigned int D.24814;
  uintptr_t * D.24815;
  long unsigned int D.24816;
  int iftmp.146;
  unsigned int D.24822;
  unsigned int D.24824;
  unsigned int D.24826;
  _Bool D.24828;
  long int D.24829;
  long int D.24830;
  int D.24833;
  int D.24834;
  long unsigned int byte_len.147;
  unsigned int D.24840;
  _Bool D.24841;
  long int D.24842;
  long int D.24843;
  long unsigned int D.24846;
  long unsigned int byte_len.148;
  unsigned int D.24848;
  unsigned int D.24849;
  _Bool D.24850;
  long int D.24851;
  long int D.24852;
  long unsigned int byte_len.149;
  long unsigned int D.24859;
  long unsigned int D.24860;
  struct MonoArrayBounds * D.24863;
  unsigned int D.24864;
  intptr_t * D.24867;
  long int D.24868;
  int D.24869;
  int profile_allocs.150;
  _Bool D.24871;
  long int D.24872;
  long int D.24873;
  struct MonoArray * D.24876;
  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.24798 = BIT_FIELD_REF <*array_class, 64, 256>;
      D.24799 = D.24798 & 1;
      if (D.24799 == 0) goto <D.24800>; else goto <D.24801>;
      <D.24800>:
      mono_class_init (array_class);
      <D.24801>:
      len = 1;
      D.24804 = array_class->rank;
      if (D.24804 == 1) goto <D.24805>; else goto <D.24802>;
      <D.24805>:
      D.24806 = array_class->byval_arg.type;
      if (D.24806 == 29) goto <D.24803>; else goto <D.24807>;
      <D.24807>:
      if (lower_bounds != 0B) goto <D.24808>; else goto <D.24802>;
      <D.24808>:
      D.24809 = *lower_bounds;
      if (D.24809 == 0) goto <D.24803>; else goto <D.24802>;
      <D.24803>:
      len = *lengths;
      if (len > 2147483647) goto <D.24810>; else goto <D.24811>;
      <D.24810>:
      arith_overflow ();
      <D.24811>:
      bounds_size = 0;
      goto <D.20820>;
      <D.24802>:
      D.24804 = array_class->rank;
      D.24812 = (long unsigned int) D.24804;
      bounds_size = D.24812 * 8;
      i = 0;
      goto <D.20819>;
      <D.20818>:
      D.24813 = (long unsigned int) i;
      D.24814 = D.24813 * 8;
      D.24815 = lengths + D.24814;
      D.24816 = *D.24815;
      if (D.24816 > 2147483647) goto <D.24817>; else goto <D.24818>;
      <D.24817>:
      arith_overflow ();
      <D.24818>:
      D.24822 = (unsigned int) len;
      if (D.24822 != 0) goto <D.24823>; else goto <D.24820>;
      <D.24823>:
      D.24813 = (long unsigned int) i;
      D.24814 = D.24813 * 8;
      D.24815 = lengths + D.24814;
      D.24816 = *D.24815;
      D.24824 = (unsigned int) D.24816;
      if (D.24824 != 0) goto <D.24825>; else goto <D.24820>;
      <D.24825>:
      D.24813 = (long unsigned int) i;
      D.24814 = D.24813 * 8;
      D.24815 = lengths + D.24814;
      D.24816 = *D.24815;
      D.24824 = (unsigned int) D.24816;
      D.24822 = (unsigned int) len;
      D.24826 = 4294967295 / D.24822;
      if (D.24824 > D.24826) goto <D.24827>; else goto <D.24820>;
      <D.24827>:
      iftmp.146 = 1;
      goto <D.24821>;
      <D.24820>:
      iftmp.146 = 0;
      <D.24821>:
      D.24828 = iftmp.146 != 0;
      D.24829 = (long int) D.24828;
      D.24830 = __builtin_expect (D.24829, 0);
      if (D.24830 != 0) goto <D.24831>; else goto <D.24832>;
      <D.24831>:
      mono_gc_out_of_memory (4294967295);
      <D.24832>:
      D.24813 = (long unsigned int) i;
      D.24814 = D.24813 * 8;
      D.24815 = lengths + D.24814;
      D.24816 = *D.24815;
      len = D.24816 * len;
      i = i + 1;
      <D.20819>:
      D.24804 = array_class->rank;
      D.24833 = (int) D.24804;
      if (D.24833 > i) goto <D.20818>; else goto <D.20820>;
      <D.20820>:
      D.24834 = mono_array_calc_byte_len (array_class, len, &byte_len);
      if (D.24834 == 0) goto <D.24835>; else goto <D.24836>;
      <D.24835>:
      mono_gc_out_of_memory (4294967295);
      <D.24836>:
      if (bounds_size != 0) goto <D.24837>; else goto <D.24838>;
      <D.24837>:
      byte_len.147 = byte_len;
      D.24840 = (unsigned int) byte_len.147;
      D.24841 = D.24840 > 4294967292;
      D.24842 = (long int) D.24841;
      D.24843 = __builtin_expect (D.24842, 0);
      if (D.24843 != 0) goto <D.24844>; else goto <D.24845>;
      <D.24844>:
      mono_gc_out_of_memory (4294967295);
      <D.24845>:
      byte_len.147 = byte_len;
      D.24846 = byte_len.147 + 3;
      byte_len.148 = D.24846 & 18446744073709551612;
      byte_len = byte_len.148;
      D.24848 = (unsigned int) bounds_size;
      D.24849 = ~D.24848;
      byte_len.147 = byte_len;
      D.24840 = (unsigned int) byte_len.147;
      D.24850 = D.24849 < D.24840;
      D.24851 = (long int) D.24850;
      D.24852 = __builtin_expect (D.24851, 0);
      if (D.24852 != 0) goto <D.24853>; else goto <D.24854>;
      <D.24853>:
      mono_gc_out_of_memory (4294967295);
      <D.24854>:
      byte_len.147 = byte_len;
      byte_len.149 = byte_len.147 + bounds_size;
      byte_len = byte_len.149;
      <D.24838>:
      vtable = mono_class_vtable_full (domain, array_class, 1);
      if (bounds_size != 0) goto <D.24856>; else goto <D.24857>;
      <D.24856>:
      byte_len.147 = byte_len;
      o = mono_gc_alloc_array (vtable, byte_len.147, len, bounds_size);
      goto <D.24858>;
      <D.24857>:
      byte_len.147 = byte_len;
      o = mono_gc_alloc_vector (vtable, byte_len.147, len);
      <D.24858>:
      array = o;
      D.24859 = mono_stats.new_object_count;
      D.24860 = D.24859 + 1;
      mono_stats.new_object_count = D.24860;
      bounds = array->bounds;
      if (bounds_size != 0) goto <D.24861>; else goto <D.24862>;
      <D.24861>:
      i = 0;
      goto <D.20822>;
      <D.20821>:
      D.24813 = (long unsigned int) i;
      D.24814 = D.24813 * 8;
      D.24863 = bounds + D.24814;
      D.24813 = (long unsigned int) i;
      D.24814 = D.24813 * 8;
      D.24815 = lengths + D.24814;
      D.24816 = *D.24815;
      D.24864 = (unsigned int) D.24816;
      D.24863->length = D.24864;
      if (lower_bounds != 0B) goto <D.24865>; else goto <D.24866>;
      <D.24865>:
      D.24813 = (long unsigned int) i;
      D.24814 = D.24813 * 8;
      D.24863 = bounds + D.24814;
      D.24813 = (long unsigned int) i;
      D.24814 = D.24813 * 8;
      D.24867 = lower_bounds + D.24814;
      D.24868 = *D.24867;
      D.24869 = (int) D.24868;
      D.24863->lower_bound = D.24869;
      <D.24866>:
      i = i + 1;
      <D.20822>:
      D.24804 = array_class->rank;
      D.24833 = (int) D.24804;
      if (D.24833 > i) goto <D.20821>; else goto <D.20823>;
      <D.20823>:
      <D.24862>:
      profile_allocs.150 = profile_allocs;
      D.24871 = profile_allocs.150 != 0;
      D.24872 = (long int) D.24871;
      D.24873 = __builtin_expect (D.24872, 0);
      if (D.24873 != 0) goto <D.24874>; else goto <D.24875>;
      <D.24874>:
      mono_profiler_allocation (o, array_class);
      <D.24875>:
      D.24876 = array;
      return D.24876;
    }
  finally
    {
      byte_len = {CLOBBER};
    }
}


arith_overflow ()
{
  struct MonoException * D.24879;

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


mono_array_new (struct MonoDomain * domain, struct MonoClass * eclass, uintptr_t n)
{
  _Bool D.24880;
  long int D.24881;
  long int D.24882;
  struct MonoArray * D.24885;
  struct MonoVTable * D.24886;
  struct MonoClass * ac;

  ac = mono_array_class_get (eclass, 1);
  D.24880 = ac == 0B;
  D.24881 = (long int) D.24880;
  D.24882 = __builtin_expect (D.24881, 0);
  if (D.24882 != 0) goto <D.24883>; else goto <D.24884>;
  <D.24883>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 4869, "ac");
  <D.24884>:
  D.24886 = mono_class_vtable_full (domain, ac, 1);
  D.24885 = mono_array_new_specific (D.24886, n);
  return D.24885;
}


mono_array_new_specific (struct MonoVTable * vtable, uintptr_t n)
{
  _Bool D.24888;
  long int D.24889;
  long int D.24890;
  struct MonoArray * D.24893;
  struct MonoClass * D.24894;
  int D.24895;
  long unsigned int byte_len.151;
  long unsigned int D.24899;
  long unsigned int D.24900;
  int profile_allocs.152;
  _Bool D.24902;
  long int D.24903;
  long int D.24904;
  struct MonoObject * o;
  struct MonoArray * ao;
  uintptr_t byte_len;

  try
    {
      D.24888 = n > 2147483647;
      D.24889 = (long int) D.24888;
      D.24890 = __builtin_expect (D.24889, 0);
      if (D.24890 != 0) goto <D.24891>; else goto <D.24892>;
      <D.24891>:
      arith_overflow ();
      D.24893 = 0B;
      return D.24893;
      <D.24892>:
      D.24894 = vtable->klass;
      D.24895 = mono_array_calc_byte_len (D.24894, n, &byte_len);
      if (D.24895 == 0) goto <D.24896>; else goto <D.24897>;
      <D.24896>:
      mono_gc_out_of_memory (4294967295);
      D.24893 = 0B;
      return D.24893;
      <D.24897>:
      byte_len.151 = byte_len;
      o = mono_gc_alloc_vector (vtable, byte_len.151, n);
      ao = o;
      D.24899 = mono_stats.new_object_count;
      D.24900 = D.24899 + 1;
      mono_stats.new_object_count = D.24900;
      profile_allocs.152 = profile_allocs;
      D.24902 = profile_allocs.152 != 0;
      D.24903 = (long int) D.24902;
      D.24904 = __builtin_expect (D.24903, 0);
      if (D.24904 != 0) goto <D.24905>; else goto <D.24906>;
      <D.24905>:
      D.24894 = vtable->klass;
      mono_profiler_allocation (o, D.24894);
      <D.24906>:
      D.24893 = ao;
      return D.24893;
    }
  finally
    {
      byte_len = {CLOBBER};
    }
}


mono_string_new_utf16 (struct MonoDomain * domain, const guint16 * text, gint32 len)
{
  _Bool D.24909;
  long int D.24910;
  long int D.24911;
  mono_unichar2 * D.24914;
  int D.24915;
  long unsigned int D.24916;
  struct MonoString * D.24917;
  struct MonoString * s;

  s = mono_string_new_size (domain, len);
  D.24909 = s == 0B;
  D.24910 = (long int) D.24909;
  D.24911 = __builtin_expect (D.24910, 0);
  if (D.24911 != 0) goto <D.24912>; else goto <D.24913>;
  <D.24912>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 4941, "s != NULL");
  <D.24913>:
  D.24914 = mono_string_chars (s);
  D.24915 = len * 2;
  D.24916 = (long unsigned int) D.24915;
  memcpy (D.24914, text, D.24916);
  D.24917 = s;
  return D.24917;
}


mono_string_new_size (struct MonoDomain * domain, gint32 len)
{
  int D.24919;
  int D.24920;
  long unsigned int D.24921;
  long unsigned int D.24922;
  struct MonoClass * D.24925;
  _Bool D.24926;
  long int D.24927;
  long int D.24928;
  int profile_allocs.153;
  _Bool D.24932;
  long int D.24933;
  long int D.24934;
  struct MonoString * D.24937;
  struct MonoString * s;
  struct MonoVTable * vtable;
  size_t size;

  D.24919 = len + 1;
  D.24920 = D.24919 * 2;
  D.24921 = (long unsigned int) D.24920;
  size = D.24921 + 24;
  D.24922 = (long unsigned int) len;
  if (D.24922 > size) goto <D.24923>; else goto <D.24924>;
  <D.24923>:
  mono_gc_out_of_memory (18446744073709551615);
  <D.24924>:
  D.24925 = mono_defaults.string_class;
  vtable = mono_class_vtable (domain, D.24925);
  D.24926 = vtable == 0B;
  D.24927 = (long int) D.24926;
  D.24928 = __builtin_expect (D.24927, 0);
  if (D.24928 != 0) goto <D.24929>; else goto <D.24930>;
  <D.24929>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 4967, "vtable");
  <D.24930>:
  s = mono_gc_alloc_string (vtable, size, len);
  profile_allocs.153 = profile_allocs;
  D.24932 = profile_allocs.153 != 0;
  D.24933 = (long int) D.24932;
  D.24934 = __builtin_expect (D.24933, 0);
  if (D.24934 != 0) goto <D.24935>; else goto <D.24936>;
  <D.24935>:
  D.24925 = mono_defaults.string_class;
  mono_profiler_allocation (s, D.24925);
  <D.24936>:
  D.24937 = s;
  return D.24937;
}


mono_string_new_len (struct MonoDomain * domain, const char * text, guint length)
{
  long int D.24939;
  struct GError * error.154;
  long int items_written.155;
  int D.24944;
  struct MonoString * D.24946;
  struct GError * error;
  struct MonoString * o;
  guint16 * ut;
  glong items_written;

  try
    {
      error = 0B;
      o = 0B;
      D.24939 = (long int) length;
      ut = eg_utf8_to_utf16_with_nuls (text, D.24939, 0B, &items_written, &error);
      error.154 = error;
      if (error.154 == 0B) goto <D.24941>; else goto <D.24942>;
      <D.24941>:
      items_written.155 = items_written;
      D.24944 = (int) items_written.155;
      o = mono_string_new_utf16 (domain, ut, D.24944);
      goto <D.24945>;
      <D.24942>:
      error.154 = error;
      monoeg_g_error_free (error.154);
      <D.24945>:
      monoeg_g_free (ut);
      D.24946 = o;
      return D.24946;
    }
  finally
    {
      error = {CLOBBER};
      items_written = {CLOBBER};
    }
}


mono_string_new (struct MonoDomain * domain, const char * text)
{
  long unsigned int D.24949;
  long int D.24950;
  struct GError * error.156;
  long int items_written.157;
  int D.24955;
  struct MonoString * D.24957;
  struct GError * error;
  struct MonoString * o;
  guint16 * ut;
  glong items_written;
  int l;

  try
    {
      error = 0B;
      o = 0B;
      D.24949 = strlen (text);
      l = (int) D.24949;
      D.24950 = (long int) l;
      ut = monoeg_g_utf8_to_utf16 (text, D.24950, 0B, &items_written, &error);
      error.156 = error;
      if (error.156 == 0B) goto <D.24952>; else goto <D.24953>;
      <D.24952>:
      items_written.157 = items_written;
      D.24955 = (int) items_written.157;
      o = mono_string_new_utf16 (domain, ut, D.24955);
      goto <D.24956>;
      <D.24953>:
      error.156 = error;
      monoeg_g_error_free (error.156);
      <D.24956>:
      monoeg_g_free (ut);
      D.24957 = o;
      return D.24957;
    }
  finally
    {
      error = {CLOBBER};
      items_written = {CLOBBER};
    }
}


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

  domain = mono_domain_get ();
  if (text != 0B) goto <D.24960>; else goto <D.24961>;
  <D.24960>:
  D.24962 = mono_string_new (domain, text);
  return D.24962;
  <D.24961>:
  D.24962 = 0B;
  return D.24962;
}


mono_value_box (struct MonoDomain * domain, struct MonoClass * class, void * value)
{
  long unsigned int D.24964;
  long unsigned int D.24965;
  _Bool D.24966;
  long int D.24967;
  long int D.24968;
  int D.24971;
  struct MonoObject * D.24974;
  int profile_allocs.158;
  _Bool D.24978;
  long int D.24979;
  long int D.24980;
  unsigned int size.159;
  unsigned int D.24984;
  int D.24985;
  _Bool D.24986;
  long int D.24987;
  long int D.24988;
  void * D.24991;
  long unsigned int D.24992;
  struct MonoObject * res;
  int size;
  struct MonoVTable * vtable;

  D.24964 = BIT_FIELD_REF <*class, 64, 256>;
  D.24965 = D.24964 & 8;
  D.24966 = D.24965 == 0;
  D.24967 = (long int) D.24966;
  D.24968 = __builtin_expect (D.24967, 0);
  if (D.24968 != 0) goto <D.24969>; else goto <D.24970>;
  <D.24969>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 5092, "class->valuetype");
  <D.24970>:
  D.24971 = mono_class_is_nullable (class);
  if (D.24971 != 0) goto <D.24972>; else goto <D.24973>;
  <D.24972>:
  D.24974 = mono_nullable_box (value, class);
  return D.24974;
  <D.24973>:
  vtable = mono_class_vtable (domain, class);
  if (vtable == 0B) goto <D.24975>; else goto <D.24976>;
  <D.24975>:
  D.24974 = 0B;
  return D.24974;
  <D.24976>:
  size = mono_class_instance_size (class);
  res = mono_object_new_alloc_specific (vtable);
  profile_allocs.158 = profile_allocs;
  D.24978 = profile_allocs.158 != 0;
  D.24979 = (long int) D.24978;
  D.24980 = __builtin_expect (D.24979, 0);
  if (D.24980 != 0) goto <D.24981>; else goto <D.24982>;
  <D.24981>:
  mono_profiler_allocation (res, class);
  <D.24982>:
  size.159 = (unsigned int) size;
  D.24984 = size.159 + 4294967280;
  size = (int) D.24984;
  D.24985 = mono_class_value_size (class, 0B);
  D.24986 = D.24985 != size;
  D.24987 = (long int) D.24986;
  D.24988 = __builtin_expect (D.24987, 0);
  if (D.24988 != 0) goto <D.24989>; else goto <D.24990>;
  <D.24989>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 5107, "size == mono_class_value_size (class, NULL)");
  <D.24990>:
  D.24991 = res + 16;
  mono_gc_wbarrier_value_copy (D.24991, value, 1, class);
  D.24964 = BIT_FIELD_REF <*class, 64, 256>;
  D.24992 = D.24964 & 2097152;
  if (D.24992 != 0) goto <D.24993>; else goto <D.24994>;
  <D.24993>:
  mono_object_register_finalizer (res);
  <D.24994>:
  D.24974 = res;
  return D.24974;
}


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.24996;
  struct MonoClass * D.24997;
  double[0:] * D.24998;
  int D.24999;
  sizetype D.25000;
  struct MonoVTable * D.25001;
  struct MonoClass * D.25002;
  struct MonoClass * D.25003;
  int D.25004;
  _Bool D.25005;
  long int D.25006;
  long int D.25007;
  int size;
  char * d;

  D.24996 = dest->obj.vtable;
  D.24997 = D.24996->klass;
  size = mono_array_element_size (D.24997);
  D.24998 = &dest->vector;
  D.24999 = size * dest_idx;
  D.25000 = (sizetype) D.24999;
  d = D.24998 + D.25000;
  D.25001 = MEM[(struct MonoObject *)dest].vtable;
  D.25002 = D.25001->klass;
  D.25003 = D.25002->element_class;
  D.25004 = mono_class_value_size (D.25003, 0B);
  D.25005 = D.25004 != size;
  D.25006 = (long int) D.25005;
  D.25007 = __builtin_expect (D.25006, 0);
  if (D.25007 != 0) goto <D.25008>; else goto <D.25009>;
  <D.25008>:
  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.25009>:
  D.25001 = MEM[(struct MonoObject *)dest].vtable;
  D.25002 = D.25001->klass;
  D.25003 = D.25002->element_class;
  mono_gc_wbarrier_value_copy (d, src, count, D.25003);
}


mono_object_get_domain (struct MonoObject * obj)
{
  struct MonoDomain * D.25010;
  struct MonoVTable * D.25011;

  D.25011 = obj->vtable;
  D.25010 = D.25011->domain;
  return D.25010;
}


mono_object_get_class (struct MonoObject * obj)
{
  struct MonoClass * D.25013;
  struct MonoVTable * D.25014;

  D.25014 = obj->vtable;
  D.25013 = D.25014->klass;
  return D.25013;
}


mono_object_get_size (struct MonoObject * o)
{
  struct MonoVTable * D.25016;
  struct MonoClass * D.25017;
  unsigned int D.25020;
  int D.25021;
  int D.25022;
  unsigned int D.25023;
  unsigned char D.25024;
  int D.25027;
  long unsigned int D.25028;
  long unsigned int D.25029;
  long unsigned int D.25030;
  struct MonoArrayBounds * D.25031;
  long unsigned int D.25034;
  long unsigned int D.25035;
  int D.25036;
  struct MonoClass * klass;

  D.25016 = o->vtable;
  klass = D.25016->klass;
  D.25017 = mono_defaults.string_class;
  if (D.25017 == klass) goto <D.25018>; else goto <D.25019>;
  <D.25018>:
  D.25021 = mono_string_length (o);
  D.25022 = D.25021 * 2;
  D.25023 = (unsigned int) D.25022;
  D.25020 = D.25023 + 26;
  return D.25020;
  <D.25019>:
  D.25016 = o->vtable;
  D.25024 = D.25016->rank;
  if (D.25024 != 0) goto <D.25025>; else goto <D.25026>;
  <D.25025>:
  {
    struct MonoArray * array;
    size_t size;

    array = o;
    D.25027 = mono_array_element_size (klass);
    D.25028 = (long unsigned int) D.25027;
    D.25029 = mono_array_length (array);
    D.25030 = D.25028 * D.25029;
    size = D.25030 + 32;
    D.25031 = array->bounds;
    if (D.25031 != 0B) goto <D.25032>; else goto <D.25033>;
    <D.25032>:
    size = size + 3;
    size = size & 18446744073709551612;
    D.25016 = o->vtable;
    D.25024 = D.25016->rank;
    D.25034 = (long unsigned int) D.25024;
    D.25035 = D.25034 * 8;
    size = D.25035 + size;
    <D.25033>:
    D.25020 = (unsigned int) size;
    return D.25020;
  }
  <D.25026>:
  D.25036 = mono_class_instance_size (klass);
  D.25020 = (unsigned int) D.25036;
  return D.25020;
}


mono_object_unbox (struct MonoObject * obj)
{
  struct MonoVTable * D.25038;
  struct MonoClass * D.25039;
  long unsigned int D.25040;
  long unsigned int D.25041;
  _Bool D.25042;
  long int D.25043;
  long int D.25044;
  void * D.25047;

  D.25038 = obj->vtable;
  D.25039 = D.25038->klass;
  D.25040 = BIT_FIELD_REF <*D.25039, 64, 256>;
  D.25041 = D.25040 & 8;
  D.25042 = D.25041 == 0;
  D.25043 = (long int) D.25042;
  D.25044 = __builtin_expect (D.25043, 0);
  if (D.25044 != 0) goto <D.25045>; else goto <D.25046>;
  <D.25045>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 5233, "obj->vtable->klass->valuetype");
  <D.25046>:
  D.25047 = obj + 16;
  return D.25047;
}


mono_object_isinst (struct MonoObject * obj, struct MonoClass * klass)
{
  long unsigned int D.25049;
  long unsigned int D.25050;
  long unsigned int D.25055;
  unsigned int D.25057;
  unsigned int D.25058;
  struct MonoObject * D.25059;
  struct MonoObject * iftmp.160;
  struct MonoVTable * D.25063;
  struct MonoClass * D.25064;
  int D.25065;

  D.25049 = BIT_FIELD_REF <*klass, 64, 256>;
  D.25050 = D.25049 & 1;
  if (D.25050 == 0) goto <D.25051>; else goto <D.25052>;
  <D.25051>:
  mono_class_init (klass);
  <D.25052>:
  D.25049 = BIT_FIELD_REF <*klass, 64, 256>;
  D.25055 = D.25049 & 4194304;
  if (D.25055 != 0) goto <D.25053>; else goto <D.25056>;
  <D.25056>:
  D.25057 = klass->flags;
  D.25058 = D.25057 & 32;
  if (D.25058 != 0) goto <D.25053>; else goto <D.25054>;
  <D.25053>:
  D.25059 = mono_object_isinst_mbyref (obj, klass);
  return D.25059;
  <D.25054>:
  if (obj == 0B) goto <D.25060>; else goto <D.25061>;
  <D.25060>:
  D.25059 = 0B;
  return D.25059;
  <D.25061>:
  D.25063 = obj->vtable;
  D.25064 = D.25063->klass;
  D.25065 = mono_class_is_assignable_from (klass, D.25064);
  if (D.25065 != 0) goto <D.25066>; else goto <D.25067>;
  <D.25066>:
  iftmp.160 = obj;
  goto <D.25068>;
  <D.25067>:
  iftmp.160 = 0B;
  <D.25068>:
  D.25059 = iftmp.160;
  return D.25059;
}


mono_object_isinst_mbyref (struct MonoObject * obj, struct MonoClass * klass)
{
  struct MonoObject * D.25072;
  unsigned int D.25073;
  unsigned int D.25074;
  short unsigned int D.25077;
  short unsigned int D.25078;
  guint8 * D.25081;
  short unsigned int D.25082;
  sizetype D.25083;
  guint8 * D.25084;
  unsigned char D.25085;
  int D.25086;
  int D.25087;
  int D.25088;
  int D.25089;
  int D.25090;
  int D.25093;
  struct MonoVTable * D.25096;
  struct MonoClass * D.25097;
  int D.25098;
  struct MonoClass * D.25102;
  struct MonoRemoteClass * D.25105;
  short unsigned int D.25106;
  short unsigned int D.25107;
  struct MonoClass * * D.25110;
  long unsigned int D.25111;
  long unsigned int D.25112;
  sizetype D.25113;
  struct MonoClass * * D.25114;
  struct MonoClass * D.25115;
  struct MonoClass * D.25118;
  unsigned char D.25121;
  _Bool D.25124;
  long int D.25125;
  long int D.25126;
  struct MonoType * D.25129;
  struct MonoReflectionType * D.25130;
  void * D.25131;
  unsigned char D.25132;
  struct MonoVTable * vt;

  if (obj == 0B) goto <D.25070>; else goto <D.25071>;
  <D.25070>:
  D.25072 = 0B;
  return D.25072;
  <D.25071>:
  vt = obj->vtable;
  D.25073 = klass->flags;
  D.25074 = D.25073 & 32;
  if (D.25074 != 0) goto <D.25075>; else goto <D.25076>;
  <D.25075>:
  D.25077 = klass->interface_id;
  D.25078 = vt->max_interface_id;
  if (D.25077 <= D.25078) goto <D.25079>; else goto <D.25080>;
  <D.25079>:
  D.25081 = vt->interface_bitmap;
  D.25077 = klass->interface_id;
  D.25082 = D.25077 >> 3;
  D.25083 = (sizetype) D.25082;
  D.25084 = D.25081 + D.25083;
  D.25085 = *D.25084;
  D.25086 = (int) D.25085;
  D.25077 = klass->interface_id;
  D.25087 = (int) D.25077;
  D.25088 = D.25087 & 7;
  D.25089 = D.25086 >> D.25088;
  D.25090 = D.25089 & 1;
  if (D.25090 != 0) goto <D.25091>; else goto <D.25092>;
  <D.25091>:
  D.25072 = obj;
  return D.25072;
  <D.25092>:
  <D.25080>:
  D.25093 = mono_class_has_variant_generic_params (klass);
  if (D.25093 != 0) goto <D.25094>; else goto <D.25095>;
  <D.25094>:
  D.25096 = obj->vtable;
  D.25097 = D.25096->klass;
  D.25098 = mono_class_is_assignable_from (klass, D.25097);
  if (D.25098 != 0) goto <D.25099>; else goto <D.25100>;
  <D.25099>:
  D.25072 = obj;
  return D.25072;
  <D.25100>:
  <D.25095>:
  goto <D.25101>;
  <D.25076>:
  {
    struct MonoClass * oklass;

    oklass = vt->klass;
    D.25102 = mono_defaults.transparent_proxy_class;
    if (D.25102 == oklass) goto <D.25103>; else goto <D.25104>;
    <D.25103>:
    D.25105 = MEM[(struct MonoTransparentProxy *)obj].remote_class;
    oklass = D.25105->proxy_class;
    <D.25104>:
    mono_class_setup_supertypes (klass);
    D.25106 = oklass->idepth;
    D.25107 = klass->idepth;
    if (D.25106 >= D.25107) goto <D.25108>; else goto <D.25109>;
    <D.25108>:
    D.25110 = oklass->supertypes;
    D.25107 = klass->idepth;
    D.25111 = (long unsigned int) D.25107;
    D.25112 = D.25111 * 8;
    D.25113 = D.25112 + 18446744073709551608;
    D.25114 = D.25110 + D.25113;
    D.25115 = *D.25114;
    if (D.25115 == klass) goto <D.25116>; else goto <D.25117>;
    <D.25116>:
    D.25072 = obj;
    return D.25072;
    <D.25117>:
    <D.25109>:
  }
  <D.25101>:
  D.25118 = vt->klass;
  D.25102 = mono_defaults.transparent_proxy_class;
  if (D.25118 == D.25102) goto <D.25119>; else goto <D.25120>;
  <D.25119>:
  D.25121 = MEM[(struct MonoTransparentProxy *)obj].custom_type_info;
  if (D.25121 != 0) goto <D.25122>; else goto <D.25123>;
  <D.25122>:
  {
    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.25124 = im == 0B;
        D.25125 = (long int) D.25124;
        D.25126 = __builtin_expect (D.25125, 0);
        if (D.25126 != 0) goto <D.25127>; else goto <D.25128>;
        <D.25127>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 5298, "im");
        <D.25128>:
        D.25129 = &klass->byval_arg;
        D.25130 = mono_type_get_object (domain, D.25129);
        pa[0] = D.25130;
        pa[1] = obj;
        res = mono_runtime_invoke (im, rp, &pa, 0B);
        D.25131 = mono_object_unbox (res);
        D.25132 = MEM[(MonoBoolean *)D.25131];
        if (D.25132 != 0) goto <D.25133>; else goto <D.25134>;
        <D.25133>:
        mono_upgrade_remote_class (domain, obj, klass);
        D.25072 = obj;
        return D.25072;
        <D.25134>:
      }
    finally
      {
        pa = {CLOBBER};
      }
  }
  <D.25123>:
  <D.25120>:
  D.25072 = 0B;
  return D.25072;
}


mono_object_castclass_mbyref (struct MonoObject * obj, struct MonoClass * klass)
{
  struct MonoObject * D.25140;
  struct MonoObject * D.25141;
  struct MonoImage * D.25144;
  struct MonoException * D.25145;

  if (obj == 0B) goto <D.25138>; else goto <D.25139>;
  <D.25138>:
  D.25140 = 0B;
  return D.25140;
  <D.25139>:
  D.25141 = mono_object_isinst_mbyref (obj, klass);
  if (D.25141 != 0B) goto <D.25142>; else goto <D.25143>;
  <D.25142>:
  D.25140 = obj;
  return D.25140;
  <D.25143>:
  D.25144 = mono_defaults.corlib;
  D.25145 = mono_exception_from_name (D.25144, "System", "InvalidCastException");
  mono_raise_exception (D.25145);
  D.25140 = 0B;
  return D.25140;
}


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

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


mono_string_is_interned_lookup (struct MonoString * str, int insert)
{
  struct MonoVTable * D.25149;
  _Bool D.25152;
  long int D.25153;
  long int D.25154;
  _Bool D.25161;
  long int D.25162;
  long int D.25163;
  struct MonoString * D.25166;
  _Bool D.25173;
  long int D.25174;
  long int D.25175;
  struct MonoString * D.25178;
  _Bool D.25183;
  long int D.25184;
  long int D.25185;
  _Bool D.25190;
  long int D.25191;
  long int D.25192;
  struct MonoGHashTable * ldstr_table;
  struct MonoString * res;
  struct MonoDomain * domain;

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

    ret = pthread_mutex_lock (&ldstr_section.mutex);
    if (ret != 0) goto <D.25150>; else goto <D.25151>;
    <D.25150>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
    <D.25151>:
    D.25152 = ret != 0;
    D.25153 = (long int) D.25152;
    D.25154 = __builtin_expect (D.25153, 0);
    if (D.25154 != 0) goto <D.25155>; else goto <D.25156>;
    <D.25155>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 5378, "ret == 0");
    <D.25156>:
  }
  res = mono_g_hash_table_lookup (ldstr_table, str);
  if (res != 0B) goto <D.25157>; else goto <D.25158>;
  <D.25157>:
  {
    int ret;

    ret = pthread_mutex_unlock (&ldstr_section.mutex);
    if (ret != 0) goto <D.25159>; else goto <D.25160>;
    <D.25159>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.25160>:
    D.25161 = ret != 0;
    D.25162 = (long int) D.25161;
    D.25163 = __builtin_expect (D.25162, 0);
    if (D.25163 != 0) goto <D.25164>; else goto <D.25165>;
    <D.25164>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 5380, "ret == 0");
    <D.25165>:
  }
  D.25166 = res;
  return D.25166;
  <D.25158>:
  if (insert != 0) goto <D.25167>; else goto <D.25168>;
  <D.25167>:
  str = mono_string_get_pinned (str);
  if (str != 0B) goto <D.25169>; else goto <D.25170>;
  <D.25169>:
  mono_g_hash_table_insert (ldstr_table, str, str);
  <D.25170>:
  {
    int ret;

    ret = pthread_mutex_unlock (&ldstr_section.mutex);
    if (ret != 0) goto <D.25171>; else goto <D.25172>;
    <D.25171>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.25172>:
    D.25173 = ret != 0;
    D.25174 = (long int) D.25173;
    D.25175 = __builtin_expect (D.25174, 0);
    if (D.25175 != 0) goto <D.25176>; else goto <D.25177>;
    <D.25176>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 5387, "ret == 0");
    <D.25177>:
  }
  D.25166 = str;
  return D.25166;
  <D.25168>:
  {
    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.25178 = ldstr_info.res;
        if (D.25178 != 0B) goto <D.25179>; else goto <D.25180>;
        <D.25179>:
        mono_g_hash_table_insert (ldstr_table, str, str);
        {
          int ret;

          ret = pthread_mutex_unlock (&ldstr_section.mutex);
          if (ret != 0) goto <D.25181>; else goto <D.25182>;
          <D.25181>:
          monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
          <D.25182>:
          D.25183 = ret != 0;
          D.25184 = (long int) D.25183;
          D.25185 = __builtin_expect (D.25184, 0);
          if (D.25185 != 0) goto <D.25186>; else goto <D.25187>;
          <D.25186>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 5402, "ret == 0");
          <D.25187>:
        }
        D.25166 = str;
        return D.25166;
        <D.25180>:
      }
    finally
      {
        ldstr_info = {CLOBBER};
      }
  }
  {
    int ret;

    ret = pthread_mutex_unlock (&ldstr_section.mutex);
    if (ret != 0) goto <D.25188>; else goto <D.25189>;
    <D.25188>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.25189>:
    D.25190 = ret != 0;
    D.25191 = (long int) D.25190;
    D.25192 = __builtin_expect (D.25191, 0);
    if (D.25192 != 0) goto <D.25193>; else goto <D.25194>;
    <D.25193>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 5406, "ret == 0");
    <D.25194>:
  }
  D.25166 = 0B;
  return D.25166;
}


str_lookup (struct MonoDomain * domain, void * user_data)
{
  struct MonoString * D.25200;
  struct MonoDomain * D.25202;
  struct MonoGHashTable * D.25203;
  struct MonoString * D.25204;
  void * D.25205;
  struct LDStrInfo * info;

  info = user_data;
  D.25200 = info->res;
  if (D.25200 != 0B) goto <D.25198>; else goto <D.25201>;
  <D.25201>:
  D.25202 = info->orig_domain;
  if (D.25202 == domain) goto <D.25198>; else goto <D.25199>;
  <D.25198>:
  return;
  <D.25199>:
  D.25203 = domain->ldstr_table;
  D.25204 = info->ins;
  D.25205 = mono_g_hash_table_lookup (D.25203, D.25204);
  info->res = D.25205;
}


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

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


mono_ldstr (struct MonoDomain * domain, struct MonoImage * image, guint32 idx)
{
  long unsigned int D.25209;
  long unsigned int D.25210;
  unsigned int D.25213;
  struct MonoString * D.25214;
  int D.25215;
  const char * D.25218;

  D.25209 = BIT_FIELD_REF <*image, 64, 192>;
  D.25210 = D.25209 & 34359738368;
  if (D.25210 != 0) goto <D.25211>; else goto <D.25212>;
  <D.25211>:
  {
    struct MonoString * str;

    D.25213 = idx | 1879048192;
    str = mono_lookup_dynamic_token (image, D.25213, 0B);
    D.25214 = str;
    return D.25214;
  }
  <D.25212>:
  D.25215 = mono_verifier_verify_string_signature (image, idx, 0B);
  if (D.25215 == 0) goto <D.25216>; else goto <D.25217>;
  <D.25216>:
  D.25214 = 0B;
  return D.25214;
  <D.25217>:
  D.25218 = mono_metadata_user_string (image, idx);
  D.25214 = mono_ldstr_metadata_sig (domain, D.25218);
  return D.25214;
}


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

  try
    {
      result = mono_string_to_utf8_checked (s, &error);
      D.25220 = mono_error_ok (&error);
      if (D.25220 == 0) goto <D.25221>; else goto <D.25222>;
      <D.25221>:
      mono_error_raise_exception (&error);
      <D.25222>:
      D.25223 = result;
      return D.25223;
    }
  finally
    {
      error = {CLOBBER};
    }
}


mono_string_to_utf8_checked (struct MonoString * s, struct MonoError * error)
{
  char * D.25228;
  int D.25229;
  mono_unichar2 * D.25232;
  long int D.25233;
  struct GError * gerror.161;
  gchar * D.25237;
  long int D.25238;
  long int written.162;
  long unsigned int D.25242;
  long unsigned int written.163;
  long int written;
  char * as;
  struct GError * gerror;

  try
    {
      written = 0;
      gerror = 0B;
      mono_error_init (error);
      if (s == 0B) goto <D.25226>; else goto <D.25227>;
      <D.25226>:
      D.25228 = 0B;
      return D.25228;
      <D.25227>:
      D.25229 = s->length;
      if (D.25229 == 0) goto <D.25230>; else goto <D.25231>;
      <D.25230>:
      D.25228 = monoeg_strdup ("");
      return D.25228;
      <D.25231>:
      D.25232 = mono_string_chars (s);
      D.25229 = s->length;
      D.25233 = (long int) D.25229;
      as = monoeg_g_utf16_to_utf8 (D.25232, D.25233, 0B, &written, &gerror);
      gerror.161 = gerror;
      if (gerror.161 != 0B) goto <D.25235>; else goto <D.25236>;
      <D.25235>:
      gerror.161 = gerror;
      D.25237 = gerror.161->message;
      mono_error_set_argument (error, "string", "%s", D.25237);
      gerror.161 = gerror;
      monoeg_g_error_free (gerror.161);
      D.25228 = 0B;
      return D.25228;
      <D.25236>:
      D.25229 = s->length;
      D.25238 = (long int) D.25229;
      written.162 = written;
      if (D.25238 > written.162) goto <D.25240>; else goto <D.25241>;
      <D.25240>:
      {
        char * as2;

        D.25229 = s->length;
        D.25242 = (long unsigned int) D.25229;
        as2 = monoeg_malloc0 (D.25242);
        written.162 = written;
        written.163 = (long unsigned int) written.162;
        memcpy (as2, as, written.163);
        monoeg_g_free (as);
        as = as2;
      }
      <D.25241>:
      D.25228 = as;
      return D.25228;
    }
  finally
    {
      written = {CLOBBER};
      gerror = {CLOBBER};
    }
}


mono_string_to_utf8_ignore (struct MonoString * s)
{
  char * D.25248;
  int D.25249;
  mono_unichar2 * D.25252;
  long int D.25253;
  long int D.25254;
  long int written.164;
  long unsigned int D.25258;
  long unsigned int written.165;
  long int written;
  char * as;

  try
    {
      written = 0;
      if (s == 0B) goto <D.25246>; else goto <D.25247>;
      <D.25246>:
      D.25248 = 0B;
      return D.25248;
      <D.25247>:
      D.25249 = s->length;
      if (D.25249 == 0) goto <D.25250>; else goto <D.25251>;
      <D.25250>:
      D.25248 = monoeg_strdup ("");
      return D.25248;
      <D.25251>:
      D.25252 = mono_string_chars (s);
      D.25249 = s->length;
      D.25253 = (long int) D.25249;
      as = monoeg_g_utf16_to_utf8 (D.25252, D.25253, 0B, &written, 0B);
      D.25249 = s->length;
      D.25254 = (long int) D.25249;
      written.164 = written;
      if (D.25254 > written.164) goto <D.25256>; else goto <D.25257>;
      <D.25256>:
      {
        char * as2;

        D.25249 = s->length;
        D.25258 = (long unsigned int) D.25249;
        as2 = monoeg_malloc0 (D.25258);
        written.164 = written;
        written.165 = (long unsigned int) written.164;
        memcpy (as2, as, written.165);
        monoeg_g_free (as);
        as = as2;
      }
      <D.25257>:
      D.25248 = as;
      return D.25248;
    }
  finally
    {
      written = {CLOBBER};
    }
}


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

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


mono_string_to_utf8_internal (struct MonoMemPool * mp, struct MonoImage * image, struct MonoString * s, gboolean ignore_error, struct MonoError * error)
{
  int D.25267;
  char * D.25270;
  long unsigned int D.25275;
  unsigned int D.25276;
  unsigned int D.25277;
  unsigned int len.166;
  unsigned int len.167;
  long unsigned int D.25283;
  char * r;
  char * mp_s;
  int len;

  if (ignore_error != 0) goto <D.25264>; else goto <D.25265>;
  <D.25264>:
  r = mono_string_to_utf8_ignore (s);
  goto <D.25266>;
  <D.25265>:
  r = mono_string_to_utf8_checked (s, error);
  D.25267 = mono_error_ok (error);
  if (D.25267 == 0) goto <D.25268>; else goto <D.25269>;
  <D.25268>:
  D.25270 = 0B;
  return D.25270;
  <D.25269>:
  <D.25266>:
  if (mp == 0B) goto <D.25271>; else goto <D.25272>;
  <D.25271>:
  if (image == 0B) goto <D.25273>; else goto <D.25274>;
  <D.25273>:
  D.25270 = r;
  return D.25270;
  <D.25274>:
  <D.25272>:
  D.25275 = strlen (r);
  D.25276 = (unsigned int) D.25275;
  D.25277 = D.25276 + 1;
  len = (int) D.25277;
  if (mp != 0B) goto <D.25278>; else goto <D.25279>;
  <D.25278>:
  len.166 = (unsigned int) len;
  mp_s = mono_mempool_alloc (mp, len.166);
  goto <D.25281>;
  <D.25279>:
  len.167 = (unsigned int) len;
  mp_s = mono_image_alloc (image, len.167);
  <D.25281>:
  D.25283 = (long unsigned int) len;
  memcpy (mp_s, r, D.25283);
  monoeg_g_free (r);
  D.25270 = mp_s;
  return D.25270;
}


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

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


mono_string_to_utf16 (struct MonoString * s)
{
  mono_unichar2 * D.25289;
  int D.25290;
  int D.25291;
  int D.25292;
  long unsigned int D.25293;
  int D.25294;
  sizetype D.25295;
  char * D.25296;
  sizetype D.25297;
  char * D.25298;
  mono_unichar2 * D.25301;
  long unsigned int D.25302;
  char * as;

  if (s == 0B) goto <D.25287>; else goto <D.25288>;
  <D.25287>:
  D.25289 = 0B;
  return D.25289;
  <D.25288>:
  D.25290 = s->length;
  D.25291 = D.25290 + 1;
  D.25292 = D.25291 * 2;
  D.25293 = (long unsigned int) D.25292;
  as = monoeg_malloc (D.25293);
  D.25290 = s->length;
  D.25294 = D.25290 * 2;
  D.25295 = (sizetype) D.25294;
  D.25296 = as + D.25295;
  *D.25296 = 0;
  D.25290 = s->length;
  D.25294 = D.25290 * 2;
  D.25295 = (sizetype) D.25294;
  D.25297 = D.25295 + 1;
  D.25298 = as + D.25297;
  *D.25298 = 0;
  D.25290 = s->length;
  if (D.25290 == 0) goto <D.25299>; else goto <D.25300>;
  <D.25299>:
  D.25289 = as;
  return D.25289;
  <D.25300>:
  D.25301 = mono_string_chars (s);
  D.25290 = s->length;
  D.25294 = D.25290 * 2;
  D.25302 = (long unsigned int) D.25294;
  memcpy (as, D.25301, D.25302);
  D.25289 = as;
  return D.25289;
}


mono_string_from_utf16 (gunichar2 * data)
{
  struct MonoString * D.25306;
  long unsigned int D.25307;
  long unsigned int D.25308;
  gunichar2 * D.25309;
  short unsigned int D.25310;
  struct MonoDomain * domain;
  int len;

  domain = mono_domain_get ();
  len = 0;
  if (data == 0B) goto <D.25304>; else goto <D.25305>;
  <D.25304>:
  D.25306 = 0B;
  return D.25306;
  <D.25305>:
  goto <D.21016>;
  <D.21015>:
  len = len + 1;
  <D.21016>:
  D.25307 = (long unsigned int) len;
  D.25308 = D.25307 * 2;
  D.25309 = data + D.25308;
  D.25310 = *D.25309;
  if (D.25310 != 0) goto <D.21015>; else goto <D.21017>;
  <D.21017>:
  D.25306 = mono_string_new_utf16 (domain, data, len);
  return D.25306;
}


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

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


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

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


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


mono_get_eh_callbacks ()
{
  struct MonoRuntimeExceptionHandlingCallbacks * D.25316;

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


mono_raise_exception (struct MonoException * ex)
{
  void (*<T2601>) (struct MonoException *) D.25318;

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


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

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


mono_wait_handle_new (struct MonoDomain * domain, void * handle)
{
  struct MonoClass * D.25320;
  struct MonoMethod * handle_set.168;
  struct MonoProperty * D.25324;
  struct MonoMethod * handle_set.169;
  struct MonoWaitHandle * D.25326;
  struct MonoWaitHandle * res;
  void * params[1];
  static struct MonoMethod * handle_set;

  try
    {
      D.25320 = mono_defaults.manualresetevent_class;
      res = mono_object_new (domain, D.25320);
      handle_set.168 = handle_set;
      if (handle_set.168 == 0B) goto <D.25322>; else goto <D.25323>;
      <D.25322>:
      D.25320 = mono_defaults.manualresetevent_class;
      D.25324 = mono_class_get_property_from_name (D.25320, "Handle");
      handle_set.169 = D.25324->set;
      handle_set = handle_set.169;
      <D.25323>:
      params[0] = &handle;
      handle_set.168 = handle_set;
      mono_runtime_invoke (handle_set.168, res, &params, 0B);
      D.25326 = res;
      return D.25326;
    }
  finally
    {
      params = {CLOBBER};
    }
}


mono_wait_handle_get_handle (struct MonoWaitHandle * handle)
{
  struct MonoClassField * f_os_handle.170;
  struct MonoClassField * f_safe_handle.171;
  struct MonoClass * D.25335;
  struct MonoClassField * f_os_handle.172;
  struct MonoClassField * f_safe_handle.173;
  void * D.25340;
  struct MonoSafeHandle * sh.174;
  static struct MonoClassField * f_os_handle;
  static struct MonoClassField * f_safe_handle;

  f_os_handle.170 = f_os_handle;
  if (f_os_handle.170 == 0B) goto <D.25330>; else goto <D.25331>;
  <D.25330>:
  f_safe_handle.171 = f_safe_handle;
  if (f_safe_handle.171 == 0B) goto <D.25333>; else goto <D.25334>;
  <D.25333>:
  D.25335 = mono_defaults.manualresetevent_class;
  f_os_handle.172 = mono_class_get_field_from_name (D.25335, "os_handle");
  f_os_handle = f_os_handle.172;
  D.25335 = mono_defaults.manualresetevent_class;
  f_safe_handle.173 = mono_class_get_field_from_name (D.25335, "safe_wait_handle");
  f_safe_handle = f_safe_handle.173;
  <D.25334>:
  <D.25331>:
  f_os_handle.170 = f_os_handle;
  if (f_os_handle.170 != 0B) goto <D.25338>; else goto <D.25339>;
  <D.25338>:
  {
    void * retval;

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

    try
      {
        f_safe_handle.171 = f_safe_handle;
        mono_field_get_value (handle, f_safe_handle.171, &sh);
        sh.174 = sh;
        D.25340 = sh.174->handle;
        return D.25340;
      }
    finally
      {
        sh = {CLOBBER};
      }
  }
}


mono_async_result_new (struct MonoDomain * domain, void * handle, struct MonoObject * state, void * data, struct MonoObject * object_data)
{
  struct MonoClass * D.25345;
  struct MonoObject * * D.25348;
  struct MonoObject * * D.25349;
  struct MonoObject * * D.25350;
  struct MonoObject * * D.25353;
  struct MonoWaitHandle * D.25354;
  struct MonoAsyncResult * D.25355;
  struct MonoAsyncResult * res;
  struct MonoObject * context;

  D.25345 = mono_defaults.asyncresult_class;
  res = mono_object_new (domain, D.25345);
  context = mono_runtime_capture_context (domain);
  if (context != 0B) goto <D.25346>; else goto <D.25347>;
  <D.25346>:
  D.25348 = &res->execution_context;
  mono_gc_wbarrier_set_field (res, D.25348, context);
  <D.25347>:
  res->data = data;
  D.25349 = &res->object_data;
  mono_gc_wbarrier_set_field (res, D.25349, object_data);
  D.25350 = &res->async_state;
  mono_gc_wbarrier_set_field (res, D.25350, state);
  if (handle != 0B) goto <D.25351>; else goto <D.25352>;
  <D.25351>:
  D.25353 = &res->handle;
  D.25354 = mono_wait_handle_new (domain, handle);
  mono_gc_wbarrier_set_field (res, D.25353, D.25354);
  <D.25352>:
  res->sync_completed = 0;
  res->completed = 0;
  D.25355 = res;
  return D.25355;
}


mono_runtime_capture_context (struct MonoDomain * domain)
{
  void * D.25359;
  void * D.25361;
  struct MonoObject * D.25364;
  void * D.25365;
  void * D.25366;
  struct MonoObject * (*RuntimeInvokeFunction) (struct MonoObject *, void * *, struct MonoObject * *, void *) runtime_invoke;

  D.25359 = domain->capture_context_runtime_invoke;
  if (D.25359 == 0B) goto <D.25357>; else goto <D.25360>;
  <D.25360>:
  D.25361 = domain->capture_context_method;
  if (D.25361 == 0B) goto <D.25357>; else goto <D.25358>;
  <D.25357>:
  {
    struct MonoMethod * method;
    struct MonoMethod * wrapper;

    method = mono_get_context_capture_method ();
    if (method == 0B) goto <D.25362>; else goto <D.25363>;
    <D.25362>:
    D.25364 = 0B;
    return D.25364;
    <D.25363>:
    wrapper = mono_marshal_get_runtime_invoke (method, 0);
    D.25365 = mono_compile_method (wrapper);
    domain->capture_context_runtime_invoke = D.25365;
    D.25366 = mono_compile_method (method);
    domain->capture_context_method = D.25366;
  }
  <D.25358>:
  D.25359 = domain->capture_context_runtime_invoke;
  runtime_invoke = (struct MonoObject * (*RuntimeInvokeFunction) (struct MonoObject *, void * *, struct MonoObject * *, void *)) D.25359;
  D.25361 = domain->capture_context_method;
  D.25364 = runtime_invoke (0B, 0B, 0B, D.25361);
  return D.25364;
}


mono_message_init (struct MonoDomain * domain, struct MonoMethodMessage * this, struct MonoReflectionMethod * method, struct MonoArray * out_args)
{
  struct MonoMethod * D.25368;
  struct MonoClass * object_array_klass.175;
  struct MonoClass * D.25372;
  _Bool D.25373;
  long int D.25374;
  long int D.25375;
  struct MonoClass * D.25378;
  struct MonoClass * D.25381;
  struct MonoReflectionMethod * * D.25384;
  struct MonoArray * * D.25385;
  struct MonoVTable * D.25386;
  short unsigned int D.25387;
  long unsigned int D.25388;
  struct MonoArray * D.25389;
  struct MonoArray * * D.25390;
  struct MonoClass * byte_array_klass.176;
  struct MonoVTable * D.25392;
  struct MonoArray * D.25393;
  long unsigned int D.25394;
  long unsigned int D.25395;
  struct MonoArray * * D.25396;
  struct MonoClass * string_array_klass.177;
  struct MonoVTable * D.25398;
  struct MonoArray * D.25399;
  long unsigned int D.25400;
  long unsigned int D.25401;
  char * * D.25402;
  char * D.25403;
  struct MonoArray * D.25404;
  long unsigned int D.25405;
  int D.25406;
  struct MonoType * D.25407;
  long unsigned int D.25408;
  long unsigned int D.25409;
  long unsigned int D.25414;
  char * D.25415;
  struct MonoArray * D.25416;
  short unsigned int D.25417;
  int D.25418;
  int D.25419;
  struct MonoArray * D.25425;
  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.25368 = method->method;
  sig = mono_method_signature (D.25368);
  object_array_klass.175 = object_array_klass;
  if (object_array_klass.175 == 0B) goto <D.25370>; else goto <D.25371>;
  <D.25370>:
  {
    struct MonoClass * klass;

    D.25372 = mono_defaults.byte_class;
    klass = mono_array_class_get (D.25372, 1);
    D.25373 = klass == 0B;
    D.25374 = (long int) D.25373;
    D.25375 = __builtin_expect (D.25374, 0);
    if (D.25375 != 0) goto <D.25376>; else goto <D.25377>;
    <D.25376>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 5891, "klass");
    <D.25377>:
    byte_array_klass = klass;
    D.25378 = mono_defaults.string_class;
    klass = mono_array_class_get (D.25378, 1);
    D.25373 = klass == 0B;
    D.25374 = (long int) D.25373;
    D.25375 = __builtin_expect (D.25374, 0);
    if (D.25375 != 0) goto <D.25379>; else goto <D.25380>;
    <D.25379>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 5895, "klass");
    <D.25380>:
    string_array_klass = klass;
    D.25381 = mono_defaults.object_class;
    klass = mono_array_class_get (D.25381, 1);
    D.25373 = klass == 0B;
    D.25374 = (long int) D.25373;
    D.25375 = __builtin_expect (D.25374, 0);
    if (D.25375 != 0) goto <D.25382>; else goto <D.25383>;
    <D.25382>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 5899, "klass");
    <D.25383>:
    mono_memory_barrier ();
    object_array_klass = klass;
  }
  <D.25371>:
  D.25384 = &this->method;
  mono_gc_wbarrier_set_field (this, D.25384, method);
  D.25385 = &this->args;
  object_array_klass.175 = object_array_klass;
  D.25386 = mono_class_vtable (domain, object_array_klass.175);
  D.25387 = sig->param_count;
  D.25388 = (long unsigned int) D.25387;
  D.25389 = mono_array_new_specific (D.25386, D.25388);
  mono_gc_wbarrier_set_field (this, D.25385, D.25389);
  D.25390 = &this->arg_types;
  byte_array_klass.176 = byte_array_klass;
  D.25392 = mono_class_vtable (domain, byte_array_klass.176);
  D.25387 = sig->param_count;
  D.25388 = (long unsigned int) D.25387;
  D.25393 = mono_array_new_specific (D.25392, D.25388);
  mono_gc_wbarrier_set_field (this, D.25390, D.25393);
  this->async_result = 0B;
  this->call_type = 0;
  D.25387 = sig->param_count;
  D.25394 = (long unsigned int) D.25387;
  D.25395 = D.25394 * 8;
  names = monoeg_malloc (D.25395);
  D.25368 = method->method;
  mono_method_get_param_names (D.25368, names);
  D.25396 = &this->names;
  string_array_klass.177 = string_array_klass;
  D.25398 = mono_class_vtable (domain, string_array_klass.177);
  D.25387 = sig->param_count;
  D.25388 = (long unsigned int) D.25387;
  D.25399 = mono_array_new_specific (D.25398, D.25388);
  mono_gc_wbarrier_set_field (this, D.25396, D.25399);
  i = 0;
  goto <D.21099>;
  <D.21098>:
  D.25400 = (long unsigned int) i;
  D.25401 = D.25400 * 8;
  D.25402 = names + D.25401;
  D.25403 = *D.25402;
  name = mono_string_new (domain, D.25403);
  {
    void * * __p;

    D.25404 = this->names;
    D.25405 = (long unsigned int) i;
    __p = mono_array_addr_with_size (D.25404, 8, D.25405);
    D.25404 = this->names;
    mono_gc_wbarrier_set_arrayref (D.25404, __p, name);
  }
  i = i + 1;
  <D.21099>:
  D.25387 = sig->param_count;
  D.25406 = (int) D.25387;
  if (D.25406 > i) goto <D.21098>; else goto <D.21100>;
  <D.21100>:
  monoeg_g_free (names);
  i = 0;
  j = 0;
  goto <D.21105>;
  <D.21104>:
  D.25407 = sig->params[i];
  D.25408 = BIT_FIELD_REF <*D.25407, 64, 64>;
  D.25409 = D.25408 & 1073741824;
  if (D.25409 != 0) goto <D.25410>; else goto <D.25411>;
  <D.25410>:
  if (out_args != 0B) goto <D.25412>; else goto <D.25413>;
  <D.25412>:
  {
    struct MonoObject * arg;

    D.25414 = (long unsigned int) j;
    D.25415 = mono_array_addr_with_size (out_args, 8, D.25414);
    arg = MEM[(void * *)D.25415];
    {
      void * * __p;

      D.25416 = this->args;
      D.25405 = (long unsigned int) i;
      __p = mono_array_addr_with_size (D.25416, 8, D.25405);
      D.25416 = this->args;
      mono_gc_wbarrier_set_arrayref (D.25416, __p, arg);
    }
    j = j + 1;
  }
  <D.25413>:
  arg_type = 2;
  D.25407 = sig->params[i];
  D.25417 = D.25407->attrs;
  D.25418 = (int) D.25417;
  D.25419 = D.25418 & 2;
  if (D.25419 == 0) goto <D.25420>; else goto <D.25421>;
  <D.25420>:
  arg_type = arg_type | 1;
  <D.25421>:
  goto <D.25422>;
  <D.25411>:
  arg_type = 1;
  D.25407 = sig->params[i];
  D.25417 = D.25407->attrs;
  D.25418 = (int) D.25417;
  D.25419 = D.25418 & 2;
  if (D.25419 != 0) goto <D.25423>; else goto <D.25424>;
  <D.25423>:
  arg_type = arg_type | 4;
  <D.25424>:
  <D.25422>:
  {
    guint8 * __p;

    D.25425 = this->arg_types;
    D.25405 = (long unsigned int) i;
    __p = mono_array_addr_with_size (D.25425, 1, D.25405);
    *__p = arg_type;
  }
  i = i + 1;
  <D.21105>:
  D.25387 = sig->param_count;
  D.25406 = (int) D.25387;
  if (D.25406 > i) goto <D.21104>; else goto <D.21106>;
  <D.21106>:
}


mono_remoting_invoke (struct MonoObject * real_proxy, struct MonoMethodMessage * msg, struct MonoObject * * exc, struct MonoArray * * out_args)
{
  struct MonoVTable * D.25426;
  struct MonoDomain * D.25427;
  struct MonoClass * D.25430;
  _Bool D.25431;
  long int D.25432;
  long int D.25433;
  struct MonoObject * D.25436;
  struct MonoMethod * im;
  void * pa[4];

  try
    {
      D.25426 = real_proxy->vtable;
      D.25427 = D.25426->domain;
      im = D.25427->private_invoke_method;
      if (im == 0B) goto <D.25428>; else goto <D.25429>;
      <D.25428>:
      D.25430 = mono_defaults.real_proxy_class;
      im = mono_class_get_method_from_name (D.25430, "PrivateInvoke", 4);
      D.25431 = im == 0B;
      D.25432 = (long int) D.25431;
      D.25433 = __builtin_expect (D.25432, 0);
      if (D.25433 != 0) goto <D.25434>; else goto <D.25435>;
      <D.25434>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 5966, "im");
      <D.25435>:
      D.25426 = real_proxy->vtable;
      D.25427 = D.25426->domain;
      D.25427->private_invoke_method = im;
      <D.25429>:
      pa[0] = real_proxy;
      pa[1] = msg;
      pa[2] = exc;
      pa[3] = out_args;
      D.25436 = mono_runtime_invoke (im, 0B, &pa, exc);
      return D.25436;
    }
  finally
    {
      pa = {CLOBBER};
    }
}


mono_message_invoke (struct MonoObject * target, struct MonoMethodMessage * msg, struct MonoObject * * exc, struct MonoArray * * out_args)
{
  struct MonoVTable * D.25441;
  struct MonoClass * D.25442;
  struct MonoClass * D.25443;
  struct MonoRemoteClass * D.25448;
  struct MonoClass * D.25449;
  long unsigned int D.25450;
  long unsigned int D.25451;
  struct MonoRealProxy * D.25453;
  struct MonoObject * D.25454;
  struct MonoAppContext * D.25455;
  struct MonoObject * D.25457;
  struct MonoReflectionMethod * D.25458;
  struct MonoType * D.25459;
  long unsigned int D.25460;
  long unsigned int D.25461;
  short unsigned int D.25464;
  int D.25465;
  struct MonoClass * object_array_klass.178;
  struct MonoClass * D.25469;
  _Bool D.25470;
  long int D.25471;
  long int D.25472;
  struct MonoVTable * D.25475;
  long unsigned int D.25476;
  struct MonoArray * D.25477;
  void * iftmp.179;
  struct MonoClass * D.25479;
  long unsigned int D.25480;
  long unsigned int D.25481;
  struct MonoArray * D.25485;
  long unsigned int D.25488;
  char * D.25489;
  struct MonoArray * D.25490;
  long unsigned int D.25491;
  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.25439>; else goto <D.25440>;
  <D.25439>:
  D.25441 = target->vtable;
  D.25442 = D.25441->klass;
  D.25443 = mono_defaults.transparent_proxy_class;
  if (D.25442 == D.25443) goto <D.25444>; else goto <D.25445>;
  <D.25444>:
  {
    struct MonoTransparentProxy * tp;

    tp = target;
    D.25448 = tp->remote_class;
    D.25449 = D.25448->proxy_class;
    D.25450 = BIT_FIELD_REF <*D.25449, 64, 256>;
    D.25451 = D.25450 & 8388608;
    if (D.25451 != 0) goto <D.25452>; else goto <D.25446>;
    <D.25452>:
    D.25453 = tp->rp;
    D.25454 = D.25453->context;
    D.25455 = mono_context_get ();
    if (D.25454 == D.25455) goto <D.25456>; else goto <D.25446>;
    <D.25456>:
    D.25453 = tp->rp;
    target = D.25453->unwrapped_server;
    goto <D.25447>;
    <D.25446>:
    D.25453 = tp->rp;
    D.25457 = mono_remoting_invoke (D.25453, msg, exc, out_args);
    return D.25457;
    <D.25447>:
  }
  <D.25445>:
  <D.25440>:
  domain = mono_domain_get ();
  D.25458 = msg->method;
  method = D.25458->method;
  sig = mono_method_signature (method);
  i = 0;
  goto <D.21131>;
  <D.21130>:
  D.25459 = sig->params[i];
  D.25460 = BIT_FIELD_REF <*D.25459, 64, 64>;
  D.25461 = D.25460 & 1073741824;
  if (D.25461 != 0) goto <D.25462>; else goto <D.25463>;
  <D.25462>:
  outarg_count = outarg_count + 1;
  <D.25463>:
  i = i + 1;
  <D.21131>:
  D.25464 = sig->param_count;
  D.25465 = (int) D.25464;
  if (D.25465 > i) goto <D.21130>; else goto <D.21132>;
  <D.21132>:
  object_array_klass.178 = object_array_klass;
  if (object_array_klass.178 == 0B) goto <D.25467>; else goto <D.25468>;
  <D.25467>:
  {
    struct MonoClass * klass;

    D.25469 = mono_defaults.object_class;
    klass = mono_array_class_get (D.25469, 1);
    D.25470 = klass == 0B;
    D.25471 = (long int) D.25470;
    D.25472 = __builtin_expect (D.25471, 0);
    if (D.25472 != 0) goto <D.25473>; else goto <D.25474>;
    <D.25473>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 6014, "klass");
    <D.25474>:
    mono_memory_barrier ();
    object_array_klass = klass;
  }
  <D.25468>:
  object_array_klass.178 = object_array_klass;
  D.25475 = mono_class_vtable (domain, object_array_klass.178);
  D.25476 = (long unsigned int) outarg_count;
  D.25477 = mono_array_new_specific (D.25475, D.25476);
  *out_args = D.25477;
  *exc = 0B;
  D.25479 = method->klass;
  D.25480 = BIT_FIELD_REF <*D.25479, 64, 256>;
  D.25481 = D.25480 & 8;
  if (D.25481 != 0) goto <D.25482>; else goto <D.25483>;
  <D.25482>:
  iftmp.179 = mono_object_unbox (target);
  goto <D.25484>;
  <D.25483>:
  iftmp.179 = target;
  <D.25484>:
  D.25485 = msg->args;
  ret = mono_runtime_invoke_array (method, iftmp.179, D.25485, exc);
  i = 0;
  j = 0;
  goto <D.21137>;
  <D.21136>:
  D.25459 = sig->params[i];
  D.25460 = BIT_FIELD_REF <*D.25459, 64, 64>;
  D.25461 = D.25460 & 1073741824;
  if (D.25461 != 0) goto <D.25486>; else goto <D.25487>;
  <D.25486>:
  {
    struct MonoObject * arg;

    D.25485 = msg->args;
    D.25488 = (long unsigned int) i;
    D.25489 = mono_array_addr_with_size (D.25485, 8, D.25488);
    arg = MEM[(void * *)D.25489];
    {
      void * * __p;

      D.25490 = *out_args;
      D.25491 = (long unsigned int) j;
      __p = mono_array_addr_with_size (D.25490, 8, D.25491);
      D.25490 = *out_args;
      mono_gc_wbarrier_set_arrayref (D.25490, __p, arg);
    }
    j = j + 1;
  }
  <D.25487>:
  i = i + 1;
  <D.21137>:
  D.25464 = sig->param_count;
  D.25465 = (int) D.25464;
  if (D.25465 > i) goto <D.21136>; else goto <D.21138>;
  <D.21138>:
  D.25457 = ret;
  return D.25457;
}


mono_object_to_string (struct MonoObject * obj, struct MonoObject * * exc)
{
  _Bool D.25493;
  long int D.25494;
  long int D.25495;
  struct MonoMethod * to_string.180;
  struct MonoClass * D.25501;
  struct MonoMethod * to_string.181;
  struct MonoClass * D.25503;
  int D.25504;
  struct MonoString * D.25507;
  static struct MonoMethod * to_string = 0B;
  struct MonoMethod * method;
  void * target;

  target = obj;
  D.25493 = obj == 0B;
  D.25494 = (long int) D.25493;
  D.25495 = __builtin_expect (D.25494, 0);
  if (D.25495 != 0) goto <D.25496>; else goto <D.25497>;
  <D.25496>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 6052, "obj");
  <D.25497>:
  to_string.180 = to_string;
  if (to_string.180 == 0B) goto <D.25499>; else goto <D.25500>;
  <D.25499>:
  D.25501 = mono_get_object_class ();
  to_string.181 = mono_class_get_method_from_name_flags (D.25501, "ToString", 0, 70);
  to_string = to_string.181;
  <D.25500>:
  to_string.180 = to_string;
  method = mono_object_get_virtual_method (obj, to_string.180);
  D.25503 = mono_method_get_class (method);
  D.25504 = mono_class_is_valuetype (D.25503);
  if (D.25504 != 0) goto <D.25505>; else goto <D.25506>;
  <D.25505>:
  target = mono_object_unbox (obj);
  <D.25506>:
  D.25507 = mono_runtime_invoke (method, target, 0B, exc);
  return D.25507;
}


mono_print_unhandled_exception (struct MonoObject * exc)
{
  struct MonoVTable * D.25509;
  struct MonoDomain * D.25510;
  struct MonoException * D.25511;
  struct MonoArray * D.25515;
  struct MonoObject * other_exc.182;
  int D.25525;
  struct MonoString * str;
  char * message;
  gboolean free_message;
  struct MonoError error;

  try
    {
      message = "";
      free_message = 0;
      D.25509 = exc->vtable;
      D.25510 = D.25509->domain;
      D.25511 = D.25510->out_of_memory_ex;
      if (D.25511 == exc) goto <D.25512>; else goto <D.25513>;
      <D.25512>:
      message = monoeg_strdup ("OutOfMemoryException");
      free_message = 1;
      goto <D.25514>;
      <D.25513>:
      D.25515 = MEM[(struct MonoException *)exc].native_trace_ips;
      if (D.25515 != 0B) goto <D.25516>; else goto <D.25517>;
      <D.25516>:
      message = mono_exception_get_native_backtrace (exc);
      free_message = 1;
      goto <D.25518>;
      <D.25517>:
      {
        struct MonoObject * other_exc;

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

              original_backtrace = mono_exception_get_managed_backtrace (exc);
              other_exc.182 = other_exc;
              nested_backtrace = mono_exception_get_managed_backtrace (other_exc.182);
              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.25522>;
            <D.25521>:
            if (str != 0B) goto <D.25523>; else goto <D.25524>;
            <D.25523>:
            message = mono_string_to_utf8_checked (str, &error);
            D.25525 = mono_error_ok (&error);
            if (D.25525 == 0) goto <D.25526>; else goto <D.25527>;
            <D.25526>:
            mono_error_cleanup (&error);
            message = "";
            goto <D.25528>;
            <D.25527>:
            free_message = 1;
            <D.25528>:
            <D.25524>:
            <D.25522>:
          }
        finally
          {
            other_exc = {CLOBBER};
          }
      }
      <D.25518>:
      <D.25514>:
      monoeg_g_printerr ("\nUnhandled Exception:\n%s\n", message);
      if (free_message != 0) goto <D.25529>; else goto <D.25530>;
      <D.25529>:
      monoeg_g_free (message);
      <D.25530>:
    }
  finally
    {
      error = {CLOBBER};
    }
}


mono_delegate_ctor_with_method (struct MonoObject * this, struct MonoObject * target, void * addr, struct MonoMethod * method)
{
  _Bool D.25531;
  long int D.25532;
  long int D.25533;
  _Bool D.25536;
  long int D.25537;
  long int D.25538;
  struct MonoVTable * D.25543;
  long unsigned int D.25544;
  long unsigned int D.25545;
  struct MonoVTable * D.25549;
  struct MonoClass * D.25550;
  struct MonoClass * D.25551;
  _Bool D.25553;
  long int D.25554;
  long int D.25555;
  void * D.25558;
  struct MonoObject * * D.25559;
  void * (*<T1e60>) (struct MonoDomain *, struct MonoClass *) arch_create_delegate_trampoline.183;
  struct MonoVTable * D.25561;
  struct MonoDomain * D.25562;
  struct MonoClass * D.25563;
  void * D.25564;
  struct MonoDelegate * delegate;
  struct MonoClass * class;

  delegate = this;
  D.25531 = this == 0B;
  D.25532 = (long int) D.25531;
  D.25533 = __builtin_expect (D.25532, 0);
  if (D.25533 != 0) goto <D.25534>; else goto <D.25535>;
  <D.25534>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 6142, "this");
  <D.25535>:
  D.25536 = addr == 0B;
  D.25537 = (long int) D.25536;
  D.25538 = __builtin_expect (D.25537, 0);
  if (D.25538 != 0) goto <D.25539>; else goto <D.25540>;
  <D.25539>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 6143, "addr");
  <D.25540>:
  if (method != 0B) goto <D.25541>; else goto <D.25542>;
  <D.25541>:
  delegate->method = method;
  <D.25542>:
  D.25543 = this->vtable;
  class = D.25543->klass;
  D.25544 = mono_stats.delegate_creations;
  D.25545 = D.25544 + 1;
  mono_stats.delegate_creations = D.25545;
  if (target != 0B) goto <D.25548>; else goto <D.25546>;
  <D.25548>:
  D.25549 = target->vtable;
  D.25550 = D.25549->klass;
  D.25551 = mono_defaults.transparent_proxy_class;
  if (D.25550 == D.25551) goto <D.25552>; else goto <D.25546>;
  <D.25552>:
  D.25553 = method == 0B;
  D.25554 = (long int) D.25553;
  D.25555 = __builtin_expect (D.25554, 0);
  if (D.25555 != 0) goto <D.25556>; else goto <D.25557>;
  <D.25556>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 6153, "method");
  <D.25557>:
  method = mono_marshal_get_remoting_invoke (method);
  D.25558 = mono_compile_method (method);
  delegate->method_ptr = D.25558;
  D.25559 = &delegate->target;
  mono_gc_wbarrier_set_field (delegate, D.25559, target);
  goto <D.25547>;
  <D.25546>:
  delegate->method_ptr = addr;
  D.25559 = &delegate->target;
  mono_gc_wbarrier_set_field (delegate, D.25559, target);
  <D.25547>:
  arch_create_delegate_trampoline.183 = arch_create_delegate_trampoline;
  D.25561 = delegate->object.vtable;
  D.25562 = D.25561->domain;
  D.25561 = delegate->object.vtable;
  D.25563 = D.25561->klass;
  D.25564 = arch_create_delegate_trampoline.183 (D.25562, D.25563);
  delegate->invoke_impl = D.25564;
}


mono_delegate_ctor (struct MonoObject * this, struct MonoObject * target, void * addr)
{
  _Bool D.25565;
  long int D.25566;
  long int D.25567;
  void * D.25570;
  struct MonoDomain * D.25573;
  struct MonoDomain * D.25576;
  void * D.25577;
  struct MonoClass * D.25580;
  struct MonoGenericContainer * D.25581;
  _Bool D.25582;
  long int D.25583;
  long int D.25584;
  struct MonoDomain * domain;
  struct MonoJitInfo * ji;
  struct MonoMethod * method;

  domain = mono_domain_get ();
  method = 0B;
  D.25565 = addr == 0B;
  D.25566 = (long int) D.25565;
  D.25567 = __builtin_expect (D.25566, 0);
  if (D.25567 != 0) goto <D.25568>; else goto <D.25569>;
  <D.25568>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 6182, "addr");
  <D.25569>:
  D.25570 = mono_get_addr_from_ftnptr (addr);
  ji = mono_jit_info_table_find (domain, D.25570);
  if (ji == 0B) goto <D.25571>; else goto <D.25572>;
  <D.25571>:
  D.25573 = mono_get_root_domain ();
  if (D.25573 != domain) goto <D.25574>; else goto <D.25575>;
  <D.25574>:
  D.25576 = mono_get_root_domain ();
  D.25577 = mono_get_addr_from_ftnptr (addr);
  ji = mono_jit_info_table_find (D.25576, D.25577);
  <D.25575>:
  <D.25572>:
  if (ji != 0B) goto <D.25578>; else goto <D.25579>;
  <D.25578>:
  method = mono_jit_info_get_method (ji);
  D.25580 = method->klass;
  D.25581 = D.25580->generic_container;
  D.25582 = D.25581 != 0B;
  D.25583 = (long int) D.25582;
  D.25584 = __builtin_expect (D.25583, 0);
  if (D.25584 != 0) goto <D.25585>; else goto <D.25586>;
  <D.25585>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 6190, "!method->klass->generic_container");
  <D.25586>:
  <D.25579>:
  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.25587;
  struct MonoReflectionMethod * D.25590;
  short unsigned int D.25591;
  int D.25592;
  struct MonoReflectionMethod * D.25594;
  struct MonoType * D.25595;
  long unsigned int D.25596;
  long unsigned int D.25597;
  long unsigned int D.25600;
  long unsigned int D.25601;
  void * * D.25602;
  void * D.25603;
  unsigned char D.25605;
  long unsigned int D.25606;
  long unsigned int D.25607;
  struct MonoArray * D.25611;
  long unsigned int D.25612;
  struct MonoDelegate * D.25617;
  struct MonoObject * D.25618;
  struct MonoMethodMessage * D.25619;
  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.25587 = mono_defaults.mono_method_message_class;
  msg = mono_object_new (domain, D.25587);
  if (invoke != 0B) goto <D.25588>; else goto <D.25589>;
  <D.25588>:
  D.25590 = mono_method_get_object (domain, invoke, 0B);
  mono_message_init (domain, msg, D.25590, 0B);
  D.25591 = sig->param_count;
  D.25592 = (int) D.25591;
  count = D.25592 + -2;
  goto <D.25593>;
  <D.25589>:
  D.25594 = mono_method_get_object (domain, method, 0B);
  mono_message_init (domain, msg, D.25594, 0B);
  D.25591 = sig->param_count;
  count = (int) D.25591;
  <D.25593>:
  i = 0;
  goto <D.21190>;
  <D.21189>:
  {
    void * vpos;
    struct MonoClass * class;
    struct MonoObject * arg;

    D.25595 = sig->params[i];
    D.25596 = BIT_FIELD_REF <*D.25595, 64, 64>;
    D.25597 = D.25596 & 1073741824;
    if (D.25597 != 0) goto <D.25598>; else goto <D.25599>;
    <D.25598>:
    D.25600 = (long unsigned int) i;
    D.25601 = D.25600 * 8;
    D.25602 = params + D.25601;
    D.25603 = *D.25602;
    vpos = MEM[(void * *)D.25603];
    goto <D.25604>;
    <D.25599>:
    D.25600 = (long unsigned int) i;
    D.25601 = D.25600 * 8;
    D.25602 = params + D.25601;
    vpos = *D.25602;
    <D.25604>:
    D.25595 = sig->params[i];
    D.25605 = D.25595->type;
    type = (int) D.25605;
    D.25595 = sig->params[i];
    class = mono_class_from_mono_type (D.25595);
    D.25606 = BIT_FIELD_REF <*class, 64, 256>;
    D.25607 = D.25606 & 8;
    if (D.25607 != 0) goto <D.25608>; else goto <D.25609>;
    <D.25608>:
    arg = mono_value_box (domain, class, vpos);
    goto <D.25610>;
    <D.25609>:
    arg = MEM[(struct MonoObject * *)vpos];
    <D.25610>:
    {
      void * * __p;

      D.25611 = msg->args;
      D.25612 = (long unsigned int) i;
      __p = mono_array_addr_with_size (D.25611, 8, D.25612);
      D.25611 = msg->args;
      mono_gc_wbarrier_set_arrayref (D.25611, __p, arg);
    }
  }
  i = i + 1;
  <D.21190>:
  if (i < count) goto <D.21189>; else goto <D.21191>;
  <D.21191>:
  if (cb != 0B) goto <D.25613>; else goto <D.25614>;
  <D.25613>:
  if (state != 0B) goto <D.25615>; else goto <D.25616>;
  <D.25615>:
  D.25600 = (long unsigned int) i;
  D.25601 = D.25600 * 8;
  D.25602 = params + D.25601;
  D.25603 = *D.25602;
  D.25617 = MEM[(struct MonoDelegate * *)D.25603];
  *cb = D.25617;
  i = i + 1;
  D.25600 = (long unsigned int) i;
  D.25601 = D.25600 * 8;
  D.25602 = params + D.25601;
  D.25603 = *D.25602;
  D.25618 = MEM[(struct MonoObject * *)D.25603];
  *state = D.25618;
  <D.25616>:
  <D.25614>:
  D.25619 = msg;
  return D.25619;
}


mono_method_return_message_restore (struct MonoMethod * method, void * * params, struct MonoArray * out_args)
{
  long unsigned int D.25623;
  long unsigned int D.25626;
  long unsigned int D.25627;
  struct MonoException * D.25632;
  long unsigned int D.25633;
  char * D.25634;
  unsigned char D.25635;
  _Bool D.25636;
  long int D.25637;
  long int D.25638;
  int D.25641;
  long unsigned int D.25644;
  long unsigned int D.25645;
  void * * D.25646;
  void * D.25647;
  struct MonoObject * * D.25648;
  struct MonoVTable * D.25652;
  long unsigned int D.25653;
  long unsigned int D.25654;
  void * D.25657;
  void * D.25658;
  const void * D.25660;
  long unsigned int D.25661;
  struct MonoClass * D.25663;
  short unsigned int D.25664;
  int D.25665;
  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.25621>; else goto <D.25622>;
  <D.25621>:
  return;
  <D.25622>:
  D.25623 = mono_array_length (out_args);
  out_len = (int) D.25623;
  if (out_len == 0) goto <D.25624>; else goto <D.25625>;
  <D.25624>:
  return;
  <D.25625>:
  i = 0;
  j = 0;
  goto <D.21207>;
  <D.21206>:
  {
    struct MonoType * pt;

    pt = sig->params[i];
    D.25626 = BIT_FIELD_REF <*pt, 64, 64>;
    D.25627 = D.25626 & 1073741824;
    if (D.25627 != 0) goto <D.25628>; else goto <D.25629>;
    <D.25628>:
    {
      char * arg;

      if (j >= out_len) goto <D.25630>; else goto <D.25631>;
      <D.25630>:
      D.25632 = mono_get_exception_execution_engine ("The proxy call returned an incorrect number of output arguments");
      mono_raise_exception (D.25632);
      <D.25631>:
      D.25633 = (long unsigned int) j;
      D.25634 = mono_array_addr_with_size (out_args, 8, D.25633);
      arg = MEM[(void * *)D.25634];
      D.25635 = pt->type;
      type = (int) D.25635;
      D.25636 = type == 1;
      D.25637 = (long int) D.25636;
      D.25638 = __builtin_expect (D.25637, 0);
      if (D.25638 != 0) goto <D.25639>; else goto <D.25640>;
      <D.25639>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 6283, "type != MONO_TYPE_VOID");
      <D.25640>:
      D.25641 = mono_type_is_reference (pt);
      if (D.25641 != 0) goto <D.25642>; else goto <D.25643>;
      <D.25642>:
      D.25644 = (long unsigned int) i;
      D.25645 = D.25644 * 8;
      D.25646 = params + D.25645;
      D.25647 = *D.25646;
      D.25648 = MEM[(struct MonoObject * * *)D.25647];
      mono_gc_wbarrier_generic_store (D.25648, arg);
      goto <D.25649>;
      <D.25643>:
      if (arg != 0B) goto <D.25650>; else goto <D.25651>;
      <D.25650>:
      {
        struct MonoClass * class;

        D.25652 = MEM[(struct MonoObject *)arg].vtable;
        class = D.25652->klass;
        size = mono_class_value_size (class, 0B);
        D.25653 = BIT_FIELD_REF <*class, 64, 256>;
        D.25654 = D.25653 & 134217728;
        if (D.25654 != 0) goto <D.25655>; else goto <D.25656>;
        <D.25655>:
        D.25644 = (long unsigned int) i;
        D.25645 = D.25644 * 8;
        D.25646 = params + D.25645;
        D.25647 = *D.25646;
        D.25657 = MEM[(void * *)D.25647];
        D.25658 = arg + 16;
        mono_gc_wbarrier_value_copy (D.25657, D.25658, 1, class);
        goto <D.25659>;
        <D.25656>:
        D.25644 = (long unsigned int) i;
        D.25645 = D.25644 * 8;
        D.25646 = params + D.25645;
        D.25647 = *D.25646;
        D.25657 = MEM[(void * *)D.25647];
        D.25660 = arg + 16;
        D.25661 = (long unsigned int) size;
        mono_gc_memmove_atomic (D.25657, D.25660, D.25661);
        <D.25659>:
      }
      goto <D.25662>;
      <D.25651>:
      D.25663 = mono_class_from_mono_type (pt);
      size = mono_class_value_size (D.25663, 0B);
      D.25644 = (long unsigned int) i;
      D.25645 = D.25644 * 8;
      D.25646 = params + D.25645;
      D.25647 = *D.25646;
      D.25657 = MEM[(void * *)D.25647];
      D.25661 = (long unsigned int) size;
      mono_gc_bzero_atomic (D.25657, D.25661);
      <D.25662>:
      <D.25649>:
      j = j + 1;
    }
    <D.25629>:
  }
  i = i + 1;
  <D.21207>:
  D.25664 = sig->param_count;
  D.25665 = (int) D.25664;
  if (D.25665 > i) goto <D.21206>; else goto <D.21208>;
  <D.21208>:
}


mono_load_remote_field (struct MonoObject * this, struct MonoClass * klass, struct MonoClassField * field, void * * res)
{
  struct MonoVTable * D.25667;
  struct MonoClass * D.25668;
  struct MonoClass * D.25669;
  _Bool D.25670;
  long int D.25671;
  long int D.25672;
  _Bool D.25675;
  long int D.25676;
  long int D.25677;
  struct MonoRemoteClass * D.25680;
  struct MonoClass * D.25681;
  long unsigned int D.25682;
  long unsigned int D.25683;
  struct MonoRealProxy * D.25686;
  struct MonoObject * D.25687;
  struct MonoAppContext * D.25688;
  struct MonoObject * D.25691;
  void * D.25692;
  struct MonoMethod * getter.184;
  struct MonoClass * D.25696;
  struct MonoMethod * getter.185;
  _Bool D.25698;
  long int D.25699;
  long int D.25700;
  struct MonoType * D.25703;
  struct MonoClass * D.25704;
  struct MonoArray * out_args.186;
  struct MonoReflectionMethod * D.25706;
  struct MonoArray * out_args.187;
  struct MonoArray * D.25708;
  struct MonoString * D.25709;
  const char * D.25710;
  struct MonoString * D.25711;
  struct MonoObject * exc.188;
  long unsigned int D.25715;
  char * D.25718;
  struct MonoObject * D.25719;
  long unsigned int D.25720;
  long unsigned int D.25721;
  void * D.25724;
  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.25667 = this->vtable;
      D.25668 = D.25667->klass;
      D.25669 = mono_defaults.transparent_proxy_class;
      D.25670 = D.25668 != D.25669;
      D.25671 = (long int) D.25670;
      D.25672 = __builtin_expect (D.25671, 0);
      if (D.25672 != 0) goto <D.25673>; else goto <D.25674>;
      <D.25673>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 6334, "mono_object_is_transparent_proxy (this)");
      <D.25674>:
      D.25675 = res == 0B;
      D.25676 = (long int) D.25675;
      D.25677 = __builtin_expect (D.25676, 0);
      if (D.25677 != 0) goto <D.25678>; else goto <D.25679>;
      <D.25678>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 6335, "res != NULL");
      <D.25679>:
      D.25680 = tp->remote_class;
      D.25681 = D.25680->proxy_class;
      D.25682 = BIT_FIELD_REF <*D.25681, 64, 256>;
      D.25683 = D.25682 & 8388608;
      if (D.25683 != 0) goto <D.25684>; else goto <D.25685>;
      <D.25684>:
      D.25686 = tp->rp;
      D.25687 = D.25686->context;
      D.25688 = mono_context_get ();
      if (D.25687 == D.25688) goto <D.25689>; else goto <D.25690>;
      <D.25689>:
      D.25686 = tp->rp;
      D.25691 = D.25686->unwrapped_server;
      mono_field_get_value (D.25691, field, res);
      D.25692 = res;
      return D.25692;
      <D.25690>:
      <D.25685>:
      getter.184 = getter;
      if (getter.184 == 0B) goto <D.25694>; else goto <D.25695>;
      <D.25694>:
      D.25696 = mono_defaults.object_class;
      getter.185 = mono_class_get_method_from_name (D.25696, "FieldGetter", -1);
      getter = getter.185;
      getter.184 = getter;
      D.25698 = getter.184 == 0B;
      D.25699 = (long int) D.25698;
      D.25700 = __builtin_expect (D.25699, 0);
      if (D.25700 != 0) goto <D.25701>; else goto <D.25702>;
      <D.25701>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 6344, "getter");
      <D.25702>:
      <D.25695>:
      D.25703 = field->type;
      field_class = mono_class_from_mono_type (D.25703);
      D.25704 = mono_defaults.mono_method_message_class;
      msg = mono_object_new (domain, D.25704);
      D.25696 = mono_defaults.object_class;
      out_args.186 = mono_array_new (domain, D.25696, 1);
      out_args = out_args.186;
      getter.184 = getter;
      D.25706 = mono_method_get_object (domain, getter.184, 0B);
      out_args.187 = out_args;
      mono_message_init (domain, msg, D.25706, out_args.187);
      full_name = mono_type_get_full_name (klass);
      {
        void * * __p;

        D.25708 = msg->args;
        __p = mono_array_addr_with_size (D.25708, 8, 0);
        D.25708 = msg->args;
        D.25709 = mono_string_new (domain, full_name);
        mono_gc_wbarrier_set_arrayref (D.25708, __p, D.25709);
      }
      {
        void * * __p;

        D.25708 = msg->args;
        __p = mono_array_addr_with_size (D.25708, 8, 1);
        D.25708 = msg->args;
        D.25710 = mono_field_get_name (field);
        D.25711 = mono_string_new (domain, D.25710);
        mono_gc_wbarrier_set_arrayref (D.25708, __p, D.25711);
      }
      monoeg_g_free (full_name);
      D.25686 = tp->rp;
      mono_remoting_invoke (D.25686, msg, &exc, &out_args);
      exc.188 = exc;
      if (exc.188 != 0B) goto <D.25713>; else goto <D.25714>;
      <D.25713>:
      exc.188 = exc;
      mono_raise_exception (exc.188);
      <D.25714>:
      out_args.187 = out_args;
      D.25715 = mono_array_length (out_args.187);
      if (D.25715 == 0) goto <D.25716>; else goto <D.25717>;
      <D.25716>:
      D.25692 = 0B;
      return D.25692;
      <D.25717>:
      out_args.187 = out_args;
      D.25718 = mono_array_addr_with_size (out_args.187, 8, 0);
      D.25719 = MEM[(struct MonoObject * *)D.25718];
      *res = D.25719;
      D.25720 = BIT_FIELD_REF <*field_class, 64, 256>;
      D.25721 = D.25720 & 8;
      if (D.25721 != 0) goto <D.25722>; else goto <D.25723>;
      <D.25722>:
      D.25724 = *res;
      D.25692 = D.25724 + 16;
      return D.25692;
      <D.25723>:
      D.25692 = res;
      return D.25692;
    }
  finally
    {
      out_args = {CLOBBER};
      exc = {CLOBBER};
    }
}


mono_load_remote_field_new (struct MonoObject * this, struct MonoClass * klass, struct MonoClassField * field)
{
  struct MonoVTable * D.25727;
  struct MonoClass * D.25728;
  struct MonoClass * D.25729;
  _Bool D.25730;
  long int D.25731;
  long int D.25732;
  struct MonoType * D.25735;
  struct MonoRemoteClass * D.25736;
  struct MonoClass * D.25737;
  long unsigned int D.25738;
  long unsigned int D.25739;
  struct MonoRealProxy * D.25742;
  struct MonoObject * D.25743;
  struct MonoAppContext * D.25744;
  long unsigned int D.25747;
  long unsigned int D.25748;
  struct MonoObject * res.189;
  struct MonoObject * res.190;
  struct MonoObject * D.25754;
  struct MonoObject * D.25755;
  struct MonoMethod * getter.191;
  struct MonoClass * D.25759;
  struct MonoMethod * getter.192;
  _Bool D.25761;
  long int D.25762;
  long int D.25763;
  struct MonoClass * D.25766;
  struct MonoArray * out_args.193;
  struct MonoReflectionMethod * D.25768;
  struct MonoArray * out_args.194;
  struct MonoArray * D.25770;
  struct MonoString * D.25771;
  const char * D.25772;
  struct MonoString * D.25773;
  struct MonoObject * exc.195;
  long unsigned int D.25777;
  char * D.25781;
  struct MonoObject * res.196;
  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.25727 = this->vtable;
      D.25728 = D.25727->klass;
      D.25729 = mono_defaults.transparent_proxy_class;
      D.25730 = D.25728 != D.25729;
      D.25731 = (long int) D.25730;
      D.25732 = __builtin_expect (D.25731, 0);
      if (D.25732 != 0) goto <D.25733>; else goto <D.25734>;
      <D.25733>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 6393, "mono_object_is_transparent_proxy (this)");
      <D.25734>:
      D.25735 = field->type;
      field_class = mono_class_from_mono_type (D.25735);
      D.25736 = tp->remote_class;
      D.25737 = D.25736->proxy_class;
      D.25738 = BIT_FIELD_REF <*D.25737, 64, 256>;
      D.25739 = D.25738 & 8388608;
      if (D.25739 != 0) goto <D.25740>; else goto <D.25741>;
      <D.25740>:
      D.25742 = tp->rp;
      D.25743 = D.25742->context;
      D.25744 = mono_context_get ();
      if (D.25743 == D.25744) goto <D.25745>; else goto <D.25746>;
      <D.25745>:
      {
        void * val;

        D.25747 = BIT_FIELD_REF <*field_class, 64, 256>;
        D.25748 = D.25747 & 8;
        if (D.25748 != 0) goto <D.25749>; else goto <D.25750>;
        <D.25749>:
        res.189 = mono_object_new (domain, field_class);
        res = res.189;
        res.190 = res;
        val = res.190 + 16;
        goto <D.25753>;
        <D.25750>:
        val = &res;
        <D.25753>:
        D.25742 = tp->rp;
        D.25754 = D.25742->unwrapped_server;
        mono_field_get_value (D.25754, field, val);
        D.25755 = res;
        return D.25755;
      }
      <D.25746>:
      <D.25741>:
      getter.191 = getter;
      if (getter.191 == 0B) goto <D.25757>; else goto <D.25758>;
      <D.25757>:
      D.25759 = mono_defaults.object_class;
      getter.192 = mono_class_get_method_from_name (D.25759, "FieldGetter", -1);
      getter = getter.192;
      getter.191 = getter;
      D.25761 = getter.191 == 0B;
      D.25762 = (long int) D.25761;
      D.25763 = __builtin_expect (D.25762, 0);
      if (D.25763 != 0) goto <D.25764>; else goto <D.25765>;
      <D.25764>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 6411, "getter");
      <D.25765>:
      <D.25758>:
      D.25766 = mono_defaults.mono_method_message_class;
      msg = mono_object_new (domain, D.25766);
      D.25759 = mono_defaults.object_class;
      out_args.193 = mono_array_new (domain, D.25759, 1);
      out_args = out_args.193;
      getter.191 = getter;
      D.25768 = mono_method_get_object (domain, getter.191, 0B);
      out_args.194 = out_args;
      mono_message_init (domain, msg, D.25768, out_args.194);
      full_name = mono_type_get_full_name (klass);
      {
        void * * __p;

        D.25770 = msg->args;
        __p = mono_array_addr_with_size (D.25770, 8, 0);
        D.25770 = msg->args;
        D.25771 = mono_string_new (domain, full_name);
        mono_gc_wbarrier_set_arrayref (D.25770, __p, D.25771);
      }
      {
        void * * __p;

        D.25770 = msg->args;
        __p = mono_array_addr_with_size (D.25770, 8, 1);
        D.25770 = msg->args;
        D.25772 = mono_field_get_name (field);
        D.25773 = mono_string_new (domain, D.25772);
        mono_gc_wbarrier_set_arrayref (D.25770, __p, D.25773);
      }
      monoeg_g_free (full_name);
      D.25742 = tp->rp;
      mono_remoting_invoke (D.25742, msg, &exc, &out_args);
      exc.195 = exc;
      if (exc.195 != 0B) goto <D.25775>; else goto <D.25776>;
      <D.25775>:
      exc.195 = exc;
      mono_raise_exception (exc.195);
      <D.25776>:
      out_args.194 = out_args;
      D.25777 = mono_array_length (out_args.194);
      if (D.25777 == 0) goto <D.25778>; else goto <D.25779>;
      <D.25778>:
      res = 0B;
      goto <D.25780>;
      <D.25779>:
      out_args.194 = out_args;
      D.25781 = mono_array_addr_with_size (out_args.194, 8, 0);
      res.196 = MEM[(struct MonoObject * *)D.25781];
      res = res.196;
      <D.25780>:
      D.25755 = res;
      return D.25755;
    }
  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.25785;
  struct MonoClass * D.25786;
  struct MonoClass * D.25787;
  _Bool D.25788;
  long int D.25789;
  long int D.25790;
  struct MonoType * D.25793;
  struct MonoRemoteClass * D.25794;
  struct MonoClass * D.25795;
  long unsigned int D.25796;
  long unsigned int D.25797;
  struct MonoRealProxy * D.25800;
  struct MonoObject * D.25801;
  struct MonoAppContext * D.25802;
  long unsigned int D.25805;
  long unsigned int D.25806;
  struct MonoObject * D.25809;
  struct MonoObject * D.25811;
  struct MonoMethod * setter.197;
  struct MonoClass * D.25815;
  struct MonoMethod * setter.198;
  _Bool D.25817;
  long int D.25818;
  long int D.25819;
  struct MonoClass * D.25825;
  struct MonoReflectionMethod * D.25826;
  struct MonoArray * D.25827;
  struct MonoString * D.25828;
  const char * D.25829;
  struct MonoString * D.25830;
  struct MonoObject * exc.199;
  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.25785 = this->vtable;
      D.25786 = D.25785->klass;
      D.25787 = mono_defaults.transparent_proxy_class;
      D.25788 = D.25786 != D.25787;
      D.25789 = (long int) D.25788;
      D.25790 = __builtin_expect (D.25789, 0);
      if (D.25790 != 0) goto <D.25791>; else goto <D.25792>;
      <D.25791>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 6460, "mono_object_is_transparent_proxy (this)");
      <D.25792>:
      D.25793 = field->type;
      field_class = mono_class_from_mono_type (D.25793);
      D.25794 = tp->remote_class;
      D.25795 = D.25794->proxy_class;
      D.25796 = BIT_FIELD_REF <*D.25795, 64, 256>;
      D.25797 = D.25796 & 8388608;
      if (D.25797 != 0) goto <D.25798>; else goto <D.25799>;
      <D.25798>:
      D.25800 = tp->rp;
      D.25801 = D.25800->context;
      D.25802 = mono_context_get ();
      if (D.25801 == D.25802) goto <D.25803>; else goto <D.25804>;
      <D.25803>:
      D.25805 = BIT_FIELD_REF <*field_class, 64, 256>;
      D.25806 = D.25805 & 8;
      if (D.25806 != 0) goto <D.25807>; else goto <D.25808>;
      <D.25807>:
      D.25800 = tp->rp;
      D.25809 = D.25800->unwrapped_server;
      mono_field_set_value (D.25809, field, val);
      goto <D.25810>;
      <D.25808>:
      D.25800 = tp->rp;
      D.25809 = D.25800->unwrapped_server;
      D.25811 = MEM[(struct MonoObject * *)val];
      mono_field_set_value (D.25809, field, D.25811);
      <D.25810>:
      return;
      <D.25804>:
      <D.25799>:
      setter.197 = setter;
      if (setter.197 == 0B) goto <D.25813>; else goto <D.25814>;
      <D.25813>:
      D.25815 = mono_defaults.object_class;
      setter.198 = mono_class_get_method_from_name (D.25815, "FieldSetter", -1);
      setter = setter.198;
      setter.197 = setter;
      D.25817 = setter.197 == 0B;
      D.25818 = (long int) D.25817;
      D.25819 = __builtin_expect (D.25818, 0);
      if (D.25819 != 0) goto <D.25820>; else goto <D.25821>;
      <D.25820>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 6472, "setter");
      <D.25821>:
      <D.25814>:
      D.25805 = BIT_FIELD_REF <*field_class, 64, 256>;
      D.25806 = D.25805 & 8;
      if (D.25806 != 0) goto <D.25822>; else goto <D.25823>;
      <D.25822>:
      arg = mono_value_box (domain, field_class, val);
      goto <D.25824>;
      <D.25823>:
      arg = MEM[(struct MonoObject * *)val];
      <D.25824>:
      D.25825 = mono_defaults.mono_method_message_class;
      msg = mono_object_new (domain, D.25825);
      setter.197 = setter;
      D.25826 = mono_method_get_object (domain, setter.197, 0B);
      mono_message_init (domain, msg, D.25826, 0B);
      full_name = mono_type_get_full_name (klass);
      {
        void * * __p;

        D.25827 = msg->args;
        __p = mono_array_addr_with_size (D.25827, 8, 0);
        D.25827 = msg->args;
        D.25828 = mono_string_new (domain, full_name);
        mono_gc_wbarrier_set_arrayref (D.25827, __p, D.25828);
      }
      {
        void * * __p;

        D.25827 = msg->args;
        __p = mono_array_addr_with_size (D.25827, 8, 1);
        D.25827 = msg->args;
        D.25829 = mono_field_get_name (field);
        D.25830 = mono_string_new (domain, D.25829);
        mono_gc_wbarrier_set_arrayref (D.25827, __p, D.25830);
      }
      {
        void * * __p;

        D.25827 = msg->args;
        __p = mono_array_addr_with_size (D.25827, 8, 2);
        D.25827 = msg->args;
        mono_gc_wbarrier_set_arrayref (D.25827, __p, arg);
      }
      monoeg_g_free (full_name);
      D.25800 = tp->rp;
      mono_remoting_invoke (D.25800, msg, &exc, &out_args);
      exc.199 = exc;
      if (exc.199 != 0B) goto <D.25832>; else goto <D.25833>;
      <D.25832>:
      exc.199 = exc;
      mono_raise_exception (exc.199);
      <D.25833>:
    }
  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.25837;
  struct MonoClass * D.25838;
  struct MonoClass * D.25839;
  _Bool D.25840;
  long int D.25841;
  long int D.25842;
  struct MonoType * D.25845;
  struct MonoRemoteClass * D.25846;
  struct MonoClass * D.25847;
  long unsigned int D.25848;
  long unsigned int D.25849;
  struct MonoRealProxy * D.25852;
  struct MonoObject * D.25853;
  struct MonoAppContext * D.25854;
  long unsigned int D.25857;
  long unsigned int D.25858;
  struct MonoObject * D.25861;
  void * D.25862;
  struct MonoMethod * setter.200;
  struct MonoClass * D.25867;
  struct MonoMethod * setter.201;
  _Bool D.25869;
  long int D.25870;
  long int D.25871;
  struct MonoClass * D.25874;
  struct MonoReflectionMethod * D.25875;
  struct MonoArray * D.25876;
  struct MonoString * D.25877;
  const char * D.25878;
  struct MonoString * D.25879;
  struct MonoObject * exc.202;
  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.25837 = this->vtable;
      D.25838 = D.25837->klass;
      D.25839 = mono_defaults.transparent_proxy_class;
      D.25840 = D.25838 != D.25839;
      D.25841 = (long int) D.25840;
      D.25842 = __builtin_expect (D.25841, 0);
      if (D.25842 != 0) goto <D.25843>; else goto <D.25844>;
      <D.25843>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 6516, "mono_object_is_transparent_proxy (this)");
      <D.25844>:
      D.25845 = field->type;
      field_class = mono_class_from_mono_type (D.25845);
      D.25846 = tp->remote_class;
      D.25847 = D.25846->proxy_class;
      D.25848 = BIT_FIELD_REF <*D.25847, 64, 256>;
      D.25849 = D.25848 & 8388608;
      if (D.25849 != 0) goto <D.25850>; else goto <D.25851>;
      <D.25850>:
      D.25852 = tp->rp;
      D.25853 = D.25852->context;
      D.25854 = mono_context_get ();
      if (D.25853 == D.25854) goto <D.25855>; else goto <D.25856>;
      <D.25855>:
      D.25857 = BIT_FIELD_REF <*field_class, 64, 256>;
      D.25858 = D.25857 & 8;
      if (D.25858 != 0) goto <D.25859>; else goto <D.25860>;
      <D.25859>:
      D.25852 = tp->rp;
      D.25861 = D.25852->unwrapped_server;
      D.25862 = arg + 16;
      mono_field_set_value (D.25861, field, D.25862);
      goto <D.25863>;
      <D.25860>:
      D.25852 = tp->rp;
      D.25861 = D.25852->unwrapped_server;
      mono_field_set_value (D.25861, field, arg);
      <D.25863>:
      return;
      <D.25856>:
      <D.25851>:
      setter.200 = setter;
      if (setter.200 == 0B) goto <D.25865>; else goto <D.25866>;
      <D.25865>:
      D.25867 = mono_defaults.object_class;
      setter.201 = mono_class_get_method_from_name (D.25867, "FieldSetter", -1);
      setter = setter.201;
      setter.200 = setter;
      D.25869 = setter.200 == 0B;
      D.25870 = (long int) D.25869;
      D.25871 = __builtin_expect (D.25870, 0);
      if (D.25871 != 0) goto <D.25872>; else goto <D.25873>;
      <D.25872>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 6528, "setter");
      <D.25873>:
      <D.25866>:
      D.25874 = mono_defaults.mono_method_message_class;
      msg = mono_object_new (domain, D.25874);
      setter.200 = setter;
      D.25875 = mono_method_get_object (domain, setter.200, 0B);
      mono_message_init (domain, msg, D.25875, 0B);
      full_name = mono_type_get_full_name (klass);
      {
        void * * __p;

        D.25876 = msg->args;
        __p = mono_array_addr_with_size (D.25876, 8, 0);
        D.25876 = msg->args;
        D.25877 = mono_string_new (domain, full_name);
        mono_gc_wbarrier_set_arrayref (D.25876, __p, D.25877);
      }
      {
        void * * __p;

        D.25876 = msg->args;
        __p = mono_array_addr_with_size (D.25876, 8, 1);
        D.25876 = msg->args;
        D.25878 = mono_field_get_name (field);
        D.25879 = mono_string_new (domain, D.25878);
        mono_gc_wbarrier_set_arrayref (D.25876, __p, D.25879);
      }
      {
        void * * __p;

        D.25876 = msg->args;
        __p = mono_array_addr_with_size (D.25876, 8, 2);
        D.25876 = msg->args;
        mono_gc_wbarrier_set_arrayref (D.25876, __p, arg);
      }
      monoeg_g_free (full_name);
      D.25852 = tp->rp;
      mono_remoting_invoke (D.25852, msg, &exc, &out_args);
      exc.202 = exc;
      if (exc.202 != 0B) goto <D.25881>; else goto <D.25882>;
      <D.25881>:
      exc.202 = exc;
      mono_raise_exception (exc.202);
      <D.25882>:
    }
  finally
    {
      out_args = {CLOBBER};
      exc = {CLOBBER};
    }
}


mono_create_ftnptr (struct MonoDomain * domain, void * addr)
{
  void * D.25886;
  void * (*<T25d0>) (struct MonoDomain *, void *) D.25887;

  D.25887 = callbacks.create_ftnptr;
  D.25886 = D.25887 (domain, addr);
  return D.25886;
}


mono_get_addr_from_ftnptr (void * descr)
{
  void * D.25889;
  void * (*<T1557>) (void *) D.25890;

  D.25890 = callbacks.get_addr_from_ftnptr;
  D.25889 = D.25890 (descr);
  return D.25889;
}


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

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


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

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


mono_array_length (struct MonoArray * array)
{
  uintptr_t D.25896;
  unsigned int D.25897;

  D.25897 = array->max_length;
  D.25896 = (uintptr_t) D.25897;
  return D.25896;
}


mono_array_addr_with_size (struct MonoArray * array, int size, uintptr_t idx)
{
  char * D.25899;
  double[0:] * D.25900;
  long unsigned int D.25901;
  long unsigned int D.25902;

  D.25900 = &array->vector;
  D.25901 = (long unsigned int) size;
  D.25902 = D.25901 * idx;
  D.25899 = D.25900 + D.25902;
  return D.25899;
}