mono_runtime_object_init (struct MonoObject * this)
{
  struct MonoVTable * D.20837;
  char * D.20840;
  struct MonoClass * D.20841;
  long unsigned int D.20842;
  long unsigned int D.20843;
  struct MonoMethod * method;
  struct MonoClass * klass;

  method = 0B;
  D.20837 = this->vtable;
  klass = D.20837->klass;
  method = mono_class_get_method_from_name (klass, ".ctor", 0);
  if (method == 0B) goto <D.20838>; else goto <D.20839>;
  <D.20838>:
  D.20840 = mono_type_get_full_name (klass);
  monoeg_g_log (0B, 4, "Could not lookup zero argument constructor for class %s", D.20840);
  <D.19095>:
  goto <D.19095>;
  <D.20839>:
  D.20841 = method->klass;
  D.20842 = BIT_FIELD_REF <*D.20841, 64, 256>;
  D.20843 = D.20842 & 1152921504606846976;
  if (D.20843 != 0) goto <D.20844>; else goto <D.20845>;
  <D.20844>:
  this = mono_object_unbox (this);
  <D.20845>:
  mono_runtime_invoke (method, this, 0B, 0B);
}


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

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


mono_thread_get_main ()
{
  struct MonoThread * D.20852;

  D.20852 = main_thread;
  return D.20852;
}


__attribute__((visibility ("hidden")))
mono_type_initialization_init ()
{
  struct GHashTable * D.20854;
  struct GHashTable * D.20855;

  InitializeCriticalSection (&type_initialization_section);
  D.20854 = monoeg_g_hash_table_new (0B, 0B);
  type_initialization_hash = D.20854;
  D.20855 = monoeg_g_hash_table_new (0B, 0B);
  blocked_thread_hash = D.20855;
  InitializeCriticalSection (&ldstr_section);
}


__attribute__((visibility ("hidden")))
mono_type_initialization_cleanup ()
{
  struct GHashTable * blocked_thread_hash.1;

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


free_main_args ()
{
  char * * main_args.2;
  long unsigned int D.20858;
  long unsigned int D.20859;
  char * * D.20860;
  char * D.20861;
  int num_main_args.3;
  int i;

  i = 0;
  goto <D.20056>;
  <D.20055>:
  main_args.2 = main_args;
  D.20858 = (long unsigned int) i;
  D.20859 = D.20858 * 8;
  D.20860 = main_args.2 + D.20859;
  D.20861 = *D.20860;
  monoeg_g_free (D.20861);
  i = i + 1;
  <D.20056>:
  num_main_args.3 = num_main_args;
  if (i < num_main_args.3) goto <D.20055>; else goto <D.20057>;
  <D.20057>:
  main_args.2 = main_args;
  monoeg_g_free (main_args.2);
}


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


__attribute__((visibility ("hidden")))
mono_runtime_class_init_full (struct MonoVTable * vtable, gboolean raise_exception)
{
  long unsigned int D.20863;
  long unsigned int D.20864;
  struct MonoException * D.20867;
  struct MonoImage * D.20868;
  long unsigned int D.20869;
  long unsigned int D.20870;
  long unsigned int D.20873;
  struct MonoDomain * D.20876;
  struct MonoException * exc.4;
  struct MonoException * exc.5;
  long unsigned int D.20885;
  _Bool D.20888;
  long int D.20889;
  long int D.20890;
  _Bool D.20897;
  long int D.20898;
  long int D.20899;
  long unsigned int D.20902;
  _Bool D.20907;
  long int D.20908;
  long int D.20909;
  struct MonoException * D.20914;
  struct GHashTable * type_initialization_hash.6;
  struct MonoDomain * D.20918;
  int D.20921;
  _Bool D.20926;
  long int D.20927;
  long int D.20928;
  struct MonoException * D.20933;
  struct CRITICAL_SECTION * D.20934;
  union mono_mutex_t * D.20935;
  _Bool D.20938;
  long int D.20939;
  long int D.20940;
  unsigned int D.20946;
  int D.20948;
  _Bool D.20951;
  long int D.20952;
  long int D.20953;
  long unsigned int D.20956;
  unsigned int D.20957;
  int D.20960;
  _Bool D.20964;
  long int D.20965;
  long int D.20966;
  long unsigned int D.20969;
  struct GHashTable * blocked_thread_hash.7;
  unsigned int D.20971;
  unsigned int D.20972;
  long unsigned int D.20973;
  void * D.20974;
  _Bool D.20977;
  long int D.20978;
  long int D.20979;
  struct MonoImage * D.20988;
  const char * D.20990;
  int D.20991;
  const char * D.20993;
  int D.20994;
  char D.20998;
  union mono_mutex_t * D.21000;
  _Bool D.21003;
  long int D.21004;
  long int D.21005;
  struct MonoGHashTable * D.21008;
  struct MonoGHashTable * D.21011;
  _Bool D.21014;
  long int D.21015;
  long int D.21016;
  _Bool D.21023;
  long int D.21024;
  long int D.21025;
  _Bool D.21031;
  long int D.21032;
  long int D.21033;
  _Bool D.21038;
  long int D.21039;
  long int D.21040;
  _Bool D.21045;
  long int D.21046;
  long int D.21047;
  const void * D.21052;
  unsigned int D.21053;
  _Bool D.21060;
  long int D.21061;
  long int D.21062;
  struct MonoException * D.21069;
  struct MonoException * exc;
  struct MonoException * exc_to_throw;
  struct MonoMethod * method;
  struct MonoClass * klass;
  gchar * full_name;

  try
    {
      method = 0B;
      D.20863 = BIT_FIELD_REF <*vtable, 64, 320>;
      D.20864 = D.20863 & 274877906944;
      if (D.20864 != 0) goto <D.20865>; else goto <D.20866>;
      <D.20865>:
      D.20867 = 0B;
      return D.20867;
      <D.20866>:
      exc = 0B;
      klass = vtable->klass;
      D.20868 = klass->image;
      D.20869 = BIT_FIELD_REF <*D.20868, 64, 192>;
      D.20870 = D.20869 & 33554432;
      if (D.20870 == 0) goto <D.20871>; else goto <D.20872>;
      <D.20871>:
      D.20868 = klass->image;
      mono_image_check_for_module_cctor (D.20868);
      D.20868 = klass->image;
      D.20869 = BIT_FIELD_REF <*D.20868, 64, 192>;
      D.20873 = D.20869 & 16777216;
      if (D.20873 != 0) goto <D.20874>; else goto <D.20875>;
      <D.20874>:
      {
        struct MonoClass * module_klass;
        struct MonoVTable * module_vtable;

        D.20868 = klass->image;
        module_klass = mono_class_get (D.20868, 33554433);
        D.20876 = vtable->domain;
        module_vtable = mono_class_vtable_full (D.20876, module_klass, raise_exception);
        if (module_vtable == 0B) goto <D.20877>; else goto <D.20878>;
        <D.20877>:
        D.20867 = 0B;
        return D.20867;
        <D.20878>:
        exc.4 = mono_runtime_class_init_full (module_vtable, raise_exception);
        exc = exc.4;
        exc.5 = exc;
        if (exc.5 != 0B) goto <D.20881>; else goto <D.20882>;
        <D.20881>:
        D.20867 = exc;
        return D.20867;
        <D.20882>:
      }
      <D.20875>:
      <D.20872>:
      method = mono_class_get_cctor (klass);
      if (method != 0B) goto <D.20883>; else goto <D.20884>;
      <D.20883>:
      {
        struct MonoDomain * domain;
        struct TypeInitializationLock * lock;
        guint32 tid;
        int do_initialization;
        struct MonoDomain * last_domain;

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

          ret = pthread_mutex_lock (&type_initialization_section.mutex);
          if (ret != 0) goto <D.20886>; else goto <D.20887>;
          <D.20886>:
          monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
          <D.20887>:
          D.20888 = ret != 0;
          D.20889 = (long int) D.20888;
          D.20890 = __builtin_expect (D.20889, 0);
          if (D.20890 != 0) goto <D.20891>; else goto <D.20892>;
          <D.20891>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 308, "ret == 0");
          <D.20892>:
        }
        D.20863 = BIT_FIELD_REF <*vtable, 64, 320>;
        D.20864 = D.20863 & 274877906944;
        if (D.20864 != 0) goto <D.20893>; else goto <D.20894>;
        <D.20893>:
        {
          int ret;

          ret = pthread_mutex_unlock (&type_initialization_section.mutex);
          if (ret != 0) goto <D.20895>; else goto <D.20896>;
          <D.20895>:
          monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
          <D.20896>:
          D.20897 = ret != 0;
          D.20898 = (long int) D.20897;
          D.20899 = __builtin_expect (D.20898, 0);
          if (D.20899 != 0) goto <D.20900>; else goto <D.20901>;
          <D.20900>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 311, "ret == 0");
          <D.20901>:
        }
        D.20867 = 0B;
        return D.20867;
        <D.20894>:
        D.20863 = BIT_FIELD_REF <*vtable, 64, 320>;
        D.20902 = D.20863 & 137438953472;
        if (D.20902 != 0) goto <D.20903>; else goto <D.20904>;
        <D.20903>:
        {
          int ret;

          ret = pthread_mutex_unlock (&type_initialization_section.mutex);
          if (ret != 0) goto <D.20905>; else goto <D.20906>;
          <D.20905>:
          monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
          <D.20906>:
          D.20907 = ret != 0;
          D.20908 = (long int) D.20907;
          D.20909 = __builtin_expect (D.20908, 0);
          if (D.20909 != 0) goto <D.20910>; else goto <D.20911>;
          <D.20910>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 315, "ret == 0");
          <D.20911>:
        }
        if (raise_exception != 0) goto <D.20912>; else goto <D.20913>;
        <D.20912>:
        D.20914 = get_type_init_exception_for_vtable (vtable);
        mono_raise_exception (D.20914);
        <D.20913>:
        D.20867 = get_type_init_exception_for_vtable (vtable);
        return D.20867;
        <D.20904>:
        type_initialization_hash.6 = type_initialization_hash;
        lock = monoeg_g_hash_table_lookup (type_initialization_hash.6, vtable);
        if (lock == 0B) goto <D.20916>; else goto <D.20917>;
        <D.20916>:
        D.20918 = mono_domain_get ();
        if (D.20918 != domain) goto <D.20919>; else goto <D.20920>;
        <D.20919>:
        last_domain = mono_domain_get ();
        D.20921 = mono_domain_set (domain, 0);
        if (D.20921 == 0) goto <D.20922>; else goto <D.20923>;
        <D.20922>:
        vtable->initialized = 1;
        {
          int ret;

          ret = pthread_mutex_unlock (&type_initialization_section.mutex);
          if (ret != 0) goto <D.20924>; else goto <D.20925>;
          <D.20924>:
          monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
          <D.20925>:
          D.20926 = ret != 0;
          D.20927 = (long int) D.20926;
          D.20928 = __builtin_expect (D.20927, 0);
          if (D.20928 != 0) goto <D.20929>; else goto <D.20930>;
          <D.20929>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 330, "ret == 0");
          <D.20930>:
        }
        if (raise_exception != 0) goto <D.20931>; else goto <D.20932>;
        <D.20931>:
        D.20933 = mono_get_exception_appdomain_unloaded ();
        mono_raise_exception (D.20933);
        <D.20932>:
        D.20867 = mono_get_exception_appdomain_unloaded ();
        return D.20867;
        <D.20923>:
        <D.20920>:
        lock = monoeg_malloc (64);
        D.20934 = &lock->initialization_section;
        InitializeCriticalSection (D.20934);
        lock->initializing_tid = tid;
        lock->waiting_count = 1;
        lock->done = 0;
        {
          int ret;

          D.20935 = &lock->initialization_section.mutex;
          ret = pthread_mutex_lock (D.20935);
          if (ret != 0) goto <D.20936>; else goto <D.20937>;
          <D.20936>:
          monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
          <D.20937>:
          D.20938 = ret != 0;
          D.20939 = (long int) D.20938;
          D.20940 = __builtin_expect (D.20939, 0);
          if (D.20940 != 0) goto <D.20941>; else goto <D.20942>;
          <D.20941>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 342, "ret == 0");
          <D.20942>:
        }
        type_initialization_hash.6 = type_initialization_hash;
        monoeg_g_hash_table_insert_replace (type_initialization_hash.6, vtable, lock, 0);
        do_initialization = 1;
        goto <D.20943>;
        <D.20917>:
        {
          void * blocked;
          struct TypeInitializationLock * pending_lock;

          D.20946 = lock->initializing_tid;
          if (D.20946 == tid) goto <D.20944>; else goto <D.20947>;
          <D.20947>:
          D.20948 = lock->done;
          if (D.20948 != 0) goto <D.20944>; else goto <D.20945>;
          <D.20944>:
          {
            int ret;

            ret = pthread_mutex_unlock (&type_initialization_section.mutex);
            if (ret != 0) goto <D.20949>; else goto <D.20950>;
            <D.20949>:
            monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
            <D.20950>:
            D.20951 = ret != 0;
            D.20952 = (long int) D.20951;
            D.20953 = __builtin_expect (D.20952, 0);
            if (D.20953 != 0) goto <D.20954>; else goto <D.20955>;
            <D.20954>:
            monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 350, "ret == 0");
            <D.20955>:
          }
          D.20867 = 0B;
          return D.20867;
          <D.20945>:
          D.20946 = lock->initializing_tid;
          D.20956 = (long unsigned int) D.20946;
          blocked = (void *) D.20956;
          goto <D.19160>;
          <D.19159>:
          D.20957 = pending_lock->initializing_tid;
          if (D.20957 == tid) goto <D.20958>; else goto <D.20959>;
          <D.20958>:
          D.20960 = pending_lock->done;
          if (D.20960 == 0) goto <D.20961>; else goto <D.19158>;
          <D.20961>:
          {
            int ret;

            ret = pthread_mutex_unlock (&type_initialization_section.mutex);
            if (ret != 0) goto <D.20962>; else goto <D.20963>;
            <D.20962>:
            monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
            <D.20963>:
            D.20964 = ret != 0;
            D.20965 = (long int) D.20964;
            D.20966 = __builtin_expect (D.20965, 0);
            if (D.20966 != 0) goto <D.20967>; else goto <D.20968>;
            <D.20967>:
            monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 358, "ret == 0");
            <D.20968>:
          }
          D.20867 = 0B;
          return D.20867;
          <D.20959>:
          D.20957 = pending_lock->initializing_tid;
          D.20969 = (long unsigned int) D.20957;
          blocked = (void *) D.20969;
          <D.19160>:
          blocked_thread_hash.7 = blocked_thread_hash;
          pending_lock = monoeg_g_hash_table_lookup (blocked_thread_hash.7, blocked);
          if (pending_lock != 0B) goto <D.19159>; else goto <D.19158>;
          <D.19158>:
          D.20971 = lock->waiting_count;
          D.20972 = D.20971 + 1;
          lock->waiting_count = D.20972;
          blocked_thread_hash.7 = blocked_thread_hash;
          D.20973 = (long unsigned int) tid;
          D.20974 = (void *) D.20973;
          monoeg_g_hash_table_insert_replace (blocked_thread_hash.7, D.20974, lock, 0);
        }
        <D.20943>:
        {
          int ret;

          ret = pthread_mutex_unlock (&type_initialization_section.mutex);
          if (ret != 0) goto <D.20975>; else goto <D.20976>;
          <D.20975>:
          monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
          <D.20976>:
          D.20977 = ret != 0;
          D.20978 = (long int) D.20977;
          D.20979 = __builtin_expect (D.20978, 0);
          if (D.20979 != 0) goto <D.20980>; else goto <D.20981>;
          <D.20980>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 373, "ret == 0");
          <D.20981>:
        }
        if (do_initialization != 0) goto <D.20982>; else goto <D.20983>;
        <D.20982>:
        mono_runtime_invoke (method, 0B, 0B, &exc);
        exc.5 = exc;
        if (exc.5 != 0B) goto <D.20986>; else goto <D.20987>;
        <D.20986>:
        D.20868 = klass->image;
        D.20988 = mono_defaults.corlib;
        if (D.20868 != D.20988) goto <D.20984>; else goto <D.20989>;
        <D.20989>:
        D.20990 = klass->name_space;
        D.20991 = strcmp (D.20990, "System");
        if (D.20991 != 0) goto <D.20984>; else goto <D.20992>;
        <D.20992>:
        D.20993 = klass->name;
        D.20994 = strcmp (D.20993, "TypeInitializationException");
        if (D.20994 != 0) goto <D.20984>; else goto <D.20985>;
        <D.20984>:
        vtable->init_failed = 1;
        D.20990 = klass->name_space;
        if (D.20990 != 0B) goto <D.20997>; else goto <D.20995>;
        <D.20997>:
        D.20990 = klass->name_space;
        D.20998 = *D.20990;
        if (D.20998 != 0) goto <D.20999>; else goto <D.20995>;
        <D.20999>:
        D.20990 = klass->name_space;
        D.20993 = klass->name;
        full_name = monoeg_g_strdup_printf ("%s.%s", D.20990, D.20993);
        goto <D.20996>;
        <D.20995>:
        D.20993 = klass->name;
        full_name = monoeg_strdup (D.20993);
        <D.20996>:
        exc.5 = exc;
        exc_to_throw = mono_get_exception_type_initialization (full_name, exc.5);
        monoeg_g_free (full_name);
        {
          int ret;

          D.21000 = &domain->lock.mutex;
          ret = pthread_mutex_lock (D.21000);
          if (ret != 0) goto <D.21001>; else goto <D.21002>;
          <D.21001>:
          monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
          <D.21002>:
          D.21003 = ret != 0;
          D.21004 = (long int) D.21003;
          D.21005 = __builtin_expect (D.21004, 0);
          if (D.21005 != 0) goto <D.21006>; else goto <D.21007>;
          <D.21006>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 397, "ret == 0");
          <D.21007>:
        }
        D.21008 = domain->type_init_exception_hash;
        if (D.21008 == 0B) goto <D.21009>; else goto <D.21010>;
        <D.21009>:
        D.21011 = mono_g_hash_table_new_type (mono_aligned_addr_hash, 0B, 2);
        domain->type_init_exception_hash = D.21011;
        <D.21010>:
        D.21008 = domain->type_init_exception_hash;
        mono_g_hash_table_insert (D.21008, klass, exc_to_throw);
        {
          int ret;

          D.21000 = &domain->lock.mutex;
          ret = pthread_mutex_unlock (D.21000);
          if (ret != 0) goto <D.21012>; else goto <D.21013>;
          <D.21012>:
          monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
          <D.21013>:
          D.21014 = ret != 0;
          D.21015 = (long int) D.21014;
          D.21016 = __builtin_expect (D.21015, 0);
          if (D.21016 != 0) goto <D.21017>; else goto <D.21018>;
          <D.21017>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 401, "ret == 0");
          <D.21018>:
        }
        <D.20985>:
        <D.20987>:
        if (last_domain != 0B) goto <D.21019>; else goto <D.21020>;
        <D.21019>:
        mono_domain_set (last_domain, 1);
        <D.21020>:
        lock->done = 1;
        {
          int ret;

          D.20935 = &lock->initialization_section.mutex;
          ret = pthread_mutex_unlock (D.20935);
          if (ret != 0) goto <D.21021>; else goto <D.21022>;
          <D.21021>:
          monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
          <D.21022>:
          D.21023 = ret != 0;
          D.21024 = (long int) D.21023;
          D.21025 = __builtin_expect (D.21024, 0);
          if (D.21025 != 0) goto <D.21026>; else goto <D.21027>;
          <D.21026>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 407, "ret == 0");
          <D.21027>:
        }
        goto <D.21028>;
        <D.20983>:
        {
          int ret;

          D.20935 = &lock->initialization_section.mutex;
          ret = pthread_mutex_lock (D.20935);
          if (ret != 0) goto <D.21029>; else goto <D.21030>;
          <D.21029>:
          monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
          <D.21030>:
          D.21031 = ret != 0;
          D.21032 = (long int) D.21031;
          D.21033 = __builtin_expect (D.21032, 0);
          if (D.21033 != 0) goto <D.21034>; else goto <D.21035>;
          <D.21034>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 410, "ret == 0");
          <D.21035>:
        }
        {
          int ret;

          D.20935 = &lock->initialization_section.mutex;
          ret = pthread_mutex_unlock (D.20935);
          if (ret != 0) goto <D.21036>; else goto <D.21037>;
          <D.21036>:
          monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
          <D.21037>:
          D.21038 = ret != 0;
          D.21039 = (long int) D.21038;
          D.21040 = __builtin_expect (D.21039, 0);
          if (D.21040 != 0) goto <D.21041>; else goto <D.21042>;
          <D.21041>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 411, "ret == 0");
          <D.21042>:
        }
        <D.21028>:
        {
          int ret;

          ret = pthread_mutex_lock (&type_initialization_section.mutex);
          if (ret != 0) goto <D.21043>; else goto <D.21044>;
          <D.21043>:
          monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
          <D.21044>:
          D.21045 = ret != 0;
          D.21046 = (long int) D.21045;
          D.21047 = __builtin_expect (D.21046, 0);
          if (D.21047 != 0) goto <D.21048>; else goto <D.21049>;
          <D.21048>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 414, "ret == 0");
          <D.21049>:
        }
        D.20946 = lock->initializing_tid;
        if (D.20946 != tid) goto <D.21050>; else goto <D.21051>;
        <D.21050>:
        blocked_thread_hash.7 = blocked_thread_hash;
        D.20973 = (long unsigned int) tid;
        D.21052 = (const void *) D.20973;
        monoeg_g_hash_table_remove (blocked_thread_hash.7, D.21052);
        <D.21051>:
        D.20971 = lock->waiting_count;
        D.21053 = D.20971 + 4294967295;
        lock->waiting_count = D.21053;
        D.20971 = lock->waiting_count;
        if (D.20971 == 0) goto <D.21054>; else goto <D.21055>;
        <D.21054>:
        D.20934 = &lock->initialization_section;
        DeleteCriticalSection (D.20934);
        type_initialization_hash.6 = type_initialization_hash;
        monoeg_g_hash_table_remove (type_initialization_hash.6, vtable);
        monoeg_g_free (lock);
        <D.21055>:
        mono_memory_barrier ();
        D.20863 = BIT_FIELD_REF <*vtable, 64, 320>;
        D.20902 = D.20863 & 137438953472;
        if (D.20902 == 0) goto <D.21056>; else goto <D.21057>;
        <D.21056>:
        vtable->initialized = 1;
        <D.21057>:
        {
          int ret;

          ret = pthread_mutex_unlock (&type_initialization_section.mutex);
          if (ret != 0) goto <D.21058>; else goto <D.21059>;
          <D.21058>:
          monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
          <D.21059>:
          D.21060 = ret != 0;
          D.21061 = (long int) D.21060;
          D.21062 = __builtin_expect (D.21061, 0);
          if (D.21062 != 0) goto <D.21063>; else goto <D.21064>;
          <D.21063>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 426, "ret == 0");
          <D.21064>:
        }
        D.20863 = BIT_FIELD_REF <*vtable, 64, 320>;
        D.20902 = D.20863 & 137438953472;
        if (D.20902 != 0) goto <D.21065>; else goto <D.21066>;
        <D.21065>:
        if (raise_exception != 0) goto <D.21067>; else goto <D.21068>;
        <D.21067>:
        D.21069 = get_type_init_exception_for_vtable (vtable);
        mono_raise_exception (D.21069);
        <D.21068>:
        D.20867 = get_type_init_exception_for_vtable (vtable);
        return D.20867;
        <D.21066>:
      }
      goto <D.21070>;
      <D.20884>:
      vtable->initialized = 1;
      D.20867 = 0B;
      return D.20867;
      <D.21070>:
      D.20867 = 0B;
      return D.20867;
    }
  finally
    {
      exc = {CLOBBER};
    }
}


__attribute__((__gnu_inline__, nothrow, leaf, pure))
strcmp (const char * __s1, const char * __s2)
{
  int iftmp.8;
  int iftmp.9;
  int D.21081;
  char * __p1;
  char * __p2;
  int __ret;

  __p1 = __s1;
  __p2 = __s2;
  __asm__ __volatile__("   slr   0,0
0: clst  %1,%2
   jo    0b
   ipm   %0
   srl   %0,28" : "=d" __ret, "=&a" __p1, "=&a" __p2 : "1" __p1, "2" __p2 : "0", "memory", "cc");
  if (__ret != 0) goto <D.21074>; else goto <D.21075>;
  <D.21074>:
  if (__ret == 1) goto <D.21077>; else goto <D.21078>;
  <D.21077>:
  iftmp.9 = -1;
  goto <D.21079>;
  <D.21078>:
  iftmp.9 = 1;
  <D.21079>:
  iftmp.8 = iftmp.9;
  goto <D.21080>;
  <D.21075>:
  iftmp.8 = 0;
  <D.21080>:
  __ret = iftmp.8;
  D.21081 = __ret;
  return D.21081;
}


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

  if (str != 0B) goto <D.21083>; else goto <D.21084>;
  <D.21083>:
  D.21085 = __strdup (str);
  return D.21085;
  <D.21084>:
  D.21085 = 0B;
  return D.21085;
}


mono_memory_barrier ()
{
  __sync_synchronize ();
}


get_type_init_exception_for_vtable (struct MonoVTable * vtable)
{
  long unsigned int D.21087;
  long unsigned int D.21088;
  char * D.21091;
  union mono_mutex_t * D.21092;
  _Bool D.21095;
  long int D.21096;
  long int D.21097;
  struct MonoGHashTable * D.21100;
  _Bool D.21105;
  long int D.21106;
  long int D.21107;
  const char * D.21114;
  char D.21116;
  const char * D.21118;
  struct MonoException * D.21119;
  struct MonoDomain * domain;
  struct MonoClass * klass;
  struct MonoException * ex;
  gchar * full_name;

  domain = vtable->domain;
  klass = vtable->klass;
  D.21087 = BIT_FIELD_REF <*vtable, 64, 320>;
  D.21088 = D.21087 & 137438953472;
  if (D.21088 == 0) goto <D.21089>; else goto <D.21090>;
  <D.21089>:
  D.21091 = 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.21091);
  <D.19127>:
  goto <D.19127>;
  <D.21090>:
  ex = 0B;
  {
    int ret;

    D.21092 = &domain->lock.mutex;
    ret = pthread_mutex_lock (D.21092);
    if (ret != 0) goto <D.21093>; else goto <D.21094>;
    <D.21093>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
    <D.21094>:
    D.21095 = ret != 0;
    D.21096 = (long int) D.21095;
    D.21097 = __builtin_expect (D.21096, 0);
    if (D.21097 != 0) goto <D.21098>; else goto <D.21099>;
    <D.21098>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 236, "ret == 0");
    <D.21099>:
  }
  D.21100 = domain->type_init_exception_hash;
  if (D.21100 != 0B) goto <D.21101>; else goto <D.21102>;
  <D.21101>:
  D.21100 = domain->type_init_exception_hash;
  ex = mono_g_hash_table_lookup (D.21100, klass);
  <D.21102>:
  {
    int ret;

    D.21092 = &domain->lock.mutex;
    ret = pthread_mutex_unlock (D.21092);
    if (ret != 0) goto <D.21103>; else goto <D.21104>;
    <D.21103>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.21104>:
    D.21105 = ret != 0;
    D.21106 = (long int) D.21105;
    D.21107 = __builtin_expect (D.21106, 0);
    if (D.21107 != 0) goto <D.21108>; else goto <D.21109>;
    <D.21108>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 239, "ret == 0");
    <D.21109>:
  }
  if (ex == 0B) goto <D.21110>; else goto <D.21111>;
  <D.21110>:
  D.21114 = klass->name_space;
  if (D.21114 != 0B) goto <D.21115>; else goto <D.21112>;
  <D.21115>:
  D.21114 = klass->name_space;
  D.21116 = *D.21114;
  if (D.21116 != 0) goto <D.21117>; else goto <D.21112>;
  <D.21117>:
  D.21114 = klass->name_space;
  D.21118 = klass->name;
  full_name = monoeg_g_strdup_printf ("%s.%s", D.21114, D.21118);
  goto <D.21113>;
  <D.21112>:
  D.21118 = klass->name;
  full_name = monoeg_strdup (D.21118);
  <D.21113>:
  ex = mono_get_exception_type_initialization (full_name, 0B);
  monoeg_g_free (full_name);
  <D.21111>:
  D.21119 = ex;
  return D.21119;
}


__attribute__((visibility ("hidden")))
mono_release_type_locks (struct MonoInternalThread * thread)
{
  _Bool D.21123;
  long int D.21124;
  long int D.21125;
  struct GHashTable * type_initialization_hash.10;
  long unsigned int D.21129;
  void * D.21130;
  _Bool D.21133;
  long int D.21134;
  long int D.21135;

  {
    int ret;

    ret = pthread_mutex_lock (&type_initialization_section.mutex);
    if (ret != 0) goto <D.21121>; else goto <D.21122>;
    <D.21121>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
    <D.21122>:
    D.21123 = ret != 0;
    D.21124 = (long int) D.21123;
    D.21125 = __builtin_expect (D.21124, 0);
    if (D.21125 != 0) goto <D.21126>; else goto <D.21127>;
    <D.21126>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 469, "ret == 0");
    <D.21127>:
  }
  type_initialization_hash.10 = type_initialization_hash;
  D.21129 = thread->tid;
  D.21130 = (void *) D.21129;
  monoeg_g_hash_table_foreach_remove (type_initialization_hash.10, release_type_locks, D.21130);
  {
    int ret;

    ret = pthread_mutex_unlock (&type_initialization_section.mutex);
    if (ret != 0) goto <D.21131>; else goto <D.21132>;
    <D.21131>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.21132>:
    D.21133 = ret != 0;
    D.21134 = (long int) D.21133;
    D.21135 = __builtin_expect (D.21134, 0);
    if (D.21135 != 0) goto <D.21136>; else goto <D.21137>;
    <D.21136>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 471, "ret == 0");
    <D.21137>:
  }
}


release_type_locks (void * key, void * value, void * user)
{
  unsigned int D.21138;
  long int user.11;
  unsigned int D.21140;
  int D.21143;
  union mono_mutex_t * D.21146;
  _Bool D.21149;
  long int D.21150;
  long int D.21151;
  unsigned int D.21154;
  unsigned int D.21155;
  struct CRITICAL_SECTION * D.21158;
  gboolean D.21159;
  struct MonoVTable * vtable;
  struct TypeInitializationLock * lock;

  vtable = key;
  lock = value;
  D.21138 = lock->initializing_tid;
  user.11 = (long int) user;
  D.21140 = (unsigned int) user.11;
  if (D.21138 == D.21140) goto <D.21141>; else goto <D.21142>;
  <D.21141>:
  D.21143 = lock->done;
  if (D.21143 == 0) goto <D.21144>; else goto <D.21145>;
  <D.21144>:
  lock->done = 1;
  vtable->init_failed = 1;
  {
    int ret;

    D.21146 = &lock->initialization_section.mutex;
    ret = pthread_mutex_unlock (D.21146);
    if (ret != 0) goto <D.21147>; else goto <D.21148>;
    <D.21147>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.21148>:
    D.21149 = ret != 0;
    D.21150 = (long int) D.21149;
    D.21151 = __builtin_expect (D.21150, 0);
    if (D.21151 != 0) goto <D.21152>; else goto <D.21153>;
    <D.21152>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 455, "ret == 0");
    <D.21153>:
  }
  D.21154 = lock->waiting_count;
  D.21155 = D.21154 + 4294967295;
  lock->waiting_count = D.21155;
  D.21154 = lock->waiting_count;
  if (D.21154 == 0) goto <D.21156>; else goto <D.21157>;
  <D.21156>:
  D.21158 = &lock->initialization_section;
  DeleteCriticalSection (D.21158);
  monoeg_g_free (lock);
  D.21159 = 1;
  return D.21159;
  <D.21157>:
  <D.21145>:
  <D.21142>:
  D.21159 = 0;
  return D.21159;
}


__attribute__((visibility ("hidden")))
mono_install_callbacks (struct MonoRuntimeCallbacks * cbs)
{
  memcpy (&callbacks, cbs, 64);
}


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

  D.21162 = __builtin_object_size (__dest, 0);
  D.21161 = __builtin___memcpy_chk (__dest, __src, __len, D.21162);
  return D.21161;
}


__attribute__((visibility ("hidden")))
mono_get_runtime_callbacks ()
{
  struct MonoRuntimeCallbacks * D.21164;

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


__attribute__((visibility ("hidden")))
mono_install_trampoline (void * (*MonoTrampoline) (struct MonoMethod *) func)
{
  void * (*<T1f15>) (struct MonoMethod *) iftmp.12;

  if (func != 0B) goto <D.21167>; else goto <D.21168>;
  <D.21167>:
  iftmp.12 = func;
  goto <D.21169>;
  <D.21168>:
  iftmp.12 = default_trampoline;
  <D.21169>:
  arch_create_jit_trampoline = iftmp.12;
}


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

  D.21170 = method;
  return D.21170;
}


__attribute__((visibility ("hidden")))
mono_install_jump_trampoline (void * (*MonoJumpTrampoline) (struct MonoDomain *, struct MonoMethod *, gboolean) func)
{
  void * (*<T1f19>) (struct MonoDomain *, struct MonoMethod *, gboolean) iftmp.13;

  if (func != 0B) goto <D.21173>; else goto <D.21174>;
  <D.21173>:
  iftmp.13 = func;
  goto <D.21175>;
  <D.21174>:
  iftmp.13 = default_jump_trampoline;
  <D.21175>:
  arch_create_jump_trampoline = iftmp.13;
}


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

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


__attribute__((visibility ("hidden")))
mono_install_remoting_trampoline (void * (*MonoRemotingTrampoline) (struct MonoDomain *, struct MonoMethod *, MonoRemotingTarget) func)
{
  void * (*<T1f1e>) (struct MonoDomain *, struct MonoMethod *, MonoRemotingTarget) iftmp.14;

  if (func != 0B) goto <D.21179>; else goto <D.21180>;
  <D.21179>:
  iftmp.14 = func;
  goto <D.21181>;
  <D.21180>:
  iftmp.14 = default_remoting_trampoline;
  <D.21181>:
  arch_create_remoting_trampoline = iftmp.14;
}


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

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


__attribute__((visibility ("hidden")))
mono_install_delegate_trampoline (void * (*MonoDelegateTrampoline) (struct MonoDomain *, struct MonoClass *) func)
{
  void * (*<T1f23>) (struct MonoDomain *, struct MonoClass *) iftmp.15;

  if (func != 0B) goto <D.21185>; else goto <D.21186>;
  <D.21185>:
  iftmp.15 = func;
  goto <D.21187>;
  <D.21186>:
  iftmp.15 = default_delegate_trampoline;
  <D.21187>:
  arch_create_delegate_trampoline = iftmp.15;
}


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

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


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


__attribute__((visibility ("hidden")))
mono_install_compile_method (void * (*MonoCompileFunc) (struct MonoMethod *) func)
{
  default_mono_compile_method = func;
}


mono_compile_method (struct MonoMethod * method)
{
  void * (*<T13b0>) (struct MonoMethod *) default_mono_compile_method.16;
  void * D.21193;

  default_mono_compile_method.16 = default_mono_compile_method;
  if (default_mono_compile_method.16 == 0B) goto <D.21191>; else goto <D.21192>;
  <D.21191>:
  monoeg_g_log (0B, 4, "compile method called on uninitialized runtime");
  <D.19233>:
  goto <D.19233>;
  D.21193 = 0B;
  return D.21193;
  <D.21192>:
  default_mono_compile_method.16 = default_mono_compile_method;
  D.21193 = default_mono_compile_method.16 (method);
  return D.21193;
}


__attribute__((visibility ("hidden")))
mono_runtime_create_jump_trampoline (struct MonoDomain * domain, struct MonoMethod * method, gboolean add_sync_wrapper)
{
  void * D.21195;
  void * (*<T1f19>) (struct MonoDomain *, struct MonoMethod *, gboolean) arch_create_jump_trampoline.17;

  arch_create_jump_trampoline.17 = arch_create_jump_trampoline;
  D.21195 = arch_create_jump_trampoline.17 (domain, method, add_sync_wrapper);
  return D.21195;
}


__attribute__((visibility ("hidden")))
mono_runtime_create_delegate_trampoline (struct MonoClass * klass)
{
  void * D.21198;
  void * (*<T1f23>) (struct MonoDomain *, struct MonoClass *) arch_create_delegate_trampoline.18;
  struct MonoDomain * D.21200;

  arch_create_delegate_trampoline.18 = arch_create_delegate_trampoline;
  D.21200 = mono_domain_get ();
  D.21198 = arch_create_delegate_trampoline.18 (D.21200, klass);
  return D.21198;
}


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


__attribute__((visibility ("hidden")))
mono_runtime_free_method (struct MonoDomain * domain, struct MonoMethod * method)
{
  void (*<T26cf>) (struct MonoDomain *, struct MonoMethod *) default_mono_free_method.19;

  default_mono_free_method.19 = default_mono_free_method;
  if (default_mono_free_method.19 != 0B) goto <D.21203>; else goto <D.21204>;
  <D.21203>:
  default_mono_free_method.19 = default_mono_free_method;
  default_mono_free_method.19 (domain, method);
  <D.21204>:
  mono_method_clear_object (domain, method);
  mono_free_method (method);
}


__attribute__((visibility ("hidden")))
mono_class_compute_bitmap (struct MonoClass * class, gsize * bitmap, int size, int offset, int * max_set, gboolean static_fields)
{
  gsize * D.21205;

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


compute_class_bitmap (struct MonoClass * class, gsize * bitmap, int size, int offset, int * max_set, gboolean static_fields)
{
  int D.21209;
  long unsigned int D.21210;
  long unsigned int D.21211;
  int D.21213;
  long unsigned int D.21214;
  long unsigned int D.21215;
  _Bool D.21218;
  long int D.21219;
  long int D.21220;
  long unsigned int D.21223;
  long unsigned int D.21224;
  long unsigned int D.21225;
  long unsigned int D.21226;
  struct MonoImage * D.21229;
  struct MonoImage * D.21230;
  const char * D.21233;
  int D.21234;
  int D.21237;
  long unsigned int D.21238;
  gsize * D.21239;
  struct MonoType * D.21242;
  short unsigned int D.21243;
  int D.21244;
  int D.21245;
  int D.21248;
  long unsigned int D.21254;
  long unsigned int D.21255;
  int D.21259;
  long unsigned int D.21262;
  long unsigned int D.21263;
  unsigned int offset.20;
  unsigned char D.21265;
  int D.21266;
  long unsigned int D.21267;
  _Bool D.21268;
  long int D.21269;
  long int D.21270;
  int iftmp.21;
  unsigned int size.22;
  unsigned int max_size.23;
  _Bool D.21280;
  long int D.21281;
  long int D.21282;
  unsigned int D.21285;
  long unsigned int D.21286;
  long unsigned int D.21287;
  gsize * D.21288;
  long unsigned int D.21289;
  unsigned int D.21290;
  long unsigned int D.21291;
  long unsigned int D.21292;
  int D.21293;
  unsigned int D.21294;
  unsigned int D.21295;
  int D.21296;
  int D.21297;
  unsigned int D.21302;
  long unsigned int D.21303;
  long unsigned int D.21304;
  gsize * D.21305;
  long unsigned int D.21306;
  long unsigned int D.21307;
  long unsigned int D.21308;
  long unsigned int D.21309;
  unsigned int D.21312;
  int D.21313;
  struct MonoClass * D.21314;
  char * D.21315;
  const char * D.21316;
  struct MonoClassField * field;
  struct MonoClass * p;
  guint32 pos;
  int max_size;

  if (static_fields != 0) goto <D.21207>; else goto <D.21208>;
  <D.21207>:
  D.21209 = mono_class_data_size (class);
  D.21210 = (long unsigned int) D.21209;
  D.21211 = D.21210 / 8;
  max_size = (int) D.21211;
  goto <D.21212>;
  <D.21208>:
  D.21213 = class->instance_size;
  D.21214 = (long unsigned int) D.21213;
  D.21215 = D.21214 / 8;
  max_size = (int) D.21215;
  <D.21212>:
  if (max_size > size) goto <D.21216>; else goto <D.21217>;
  <D.21216>:
  D.21218 = offset > 0;
  D.21219 = (long int) D.21218;
  D.21220 = __builtin_expect (D.21219, 0);
  if (D.21220 != 0) goto <D.21221>; else goto <D.21222>;
  <D.21221>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 664, "offset <= 0");
  <D.21222>:
  D.21223 = (long unsigned int) max_size;
  D.21224 = D.21223 + 63;
  D.21225 = D.21224 / 64;
  D.21226 = D.21225 * 8;
  bitmap = monoeg_malloc0 (D.21226);
  size = max_size;
  <D.21217>:
  if (static_fields == 0) goto <D.21227>; else goto <D.21228>;
  <D.21227>:
  D.21229 = class->image;
  D.21230 = mono_defaults.corlib;
  if (D.21229 == D.21230) goto <D.21231>; else goto <D.21232>;
  <D.21231>:
  D.21233 = class->name;
  D.21234 = strcmp ("Ephemeron", D.21233);
  if (D.21234 == 0) goto <D.21235>; else goto <D.21236>;
  <D.21235>:
  *max_set = 0;
  D.21237 = size / 8;
  D.21238 = (long unsigned int) D.21237;
  memset (bitmap, 0, D.21238);
  D.21239 = bitmap;
  return D.21239;
  <D.21236>:
  <D.21232>:
  <D.21228>:
  p = class;
  goto <D.19296>;
  <D.19295>:
  {
    void * iter;

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

          if (static_fields != 0) goto <D.21240>; else goto <D.21241>;
          <D.21240>:
          D.21242 = field->type;
          D.21243 = D.21242->attrs;
          D.21244 = (int) D.21243;
          D.21245 = D.21244 & 272;
          if (D.21245 == 0) goto <D.21246>; else goto <D.21247>;
          <D.21246>:
          // predicted unlikely by continue predictor.
          goto <D.19264>;
          <D.21247>:
          D.21242 = field->type;
          D.21243 = D.21242->attrs;
          D.21244 = (int) D.21243;
          D.21248 = D.21244 & 64;
          if (D.21248 != 0) goto <D.21249>; else goto <D.21250>;
          <D.21249>:
          // predicted unlikely by continue predictor.
          goto <D.19264>;
          <D.21250>:
          goto <D.21251>;
          <D.21241>:
          D.21242 = field->type;
          D.21243 = D.21242->attrs;
          D.21244 = (int) D.21243;
          D.21245 = D.21244 & 272;
          if (D.21245 != 0) goto <D.21252>; else goto <D.21253>;
          <D.21252>:
          // predicted unlikely by continue predictor.
          goto <D.19264>;
          <D.21253>:
          <D.21251>:
          D.21242 = field->type;
          D.21254 = BIT_FIELD_REF <*D.21242, 64, 64>;
          D.21255 = D.21254 & 8589934592;
          if (D.21255 != 0) goto <D.19265>; else goto <D.21256>;
          <D.21256>:
          if (static_fields != 0) goto <D.21257>; else goto <D.21258>;
          <D.21257>:
          D.21259 = field->offset;
          if (D.21259 == -1) goto <D.21260>; else goto <D.21261>;
          <D.21260>:
          // predicted unlikely by continue predictor.
          goto <D.19264>;
          <D.21261>:
          <D.21258>:
          D.21259 = field->offset;
          D.21262 = (long unsigned int) D.21259;
          D.21263 = D.21262 / 8;
          pos = (guint32) D.21263;
          offset.20 = (unsigned int) offset;
          pos = pos + offset.20;
          D.21242 = field->type;
          type = mono_type_get_underlying_type (D.21242);
          D.21265 = type->type;
          D.21266 = (int) D.21265;
          switch (D.21266) <default: <D.19291>, case 2: <D.19289>, case 3: <D.19290>, case 4: <D.19279>, case 5: <D.19280>, case 6: <D.19281>, case 7: <D.19282>, case 8: <D.19283>, case 9: <D.19284>, case 10: <D.19285>, case 11: <D.19286>, case 12: <D.19287>, case 13: <D.19288>, case 14: <D.19271>, case 15: <D.19267>, case 17: <D.19277>, case 18: <D.19273>, case 20: <D.19275>, case 21: <D.19276>, case 24: <D.19266>, case 25: <D.19270>, case 27: <D.19268>, case 28: <D.19274>, case 29: <D.19272>>
          <D.19266>:
          <D.19267>:
          <D.19268>:
          goto <D.19269>;
          <D.19270>:
          goto <D.19269>;
          <D.19271>:
          <D.19272>:
          <D.19273>:
          <D.19274>:
          <D.19275>:
          D.21259 = field->offset;
          D.21262 = (long unsigned int) D.21259;
          D.21267 = D.21262 & 7;
          D.21268 = D.21267 != 0;
          D.21269 = (long int) D.21268;
          D.21270 = __builtin_expect (D.21269, 0);
          if (D.21270 != 0) goto <D.21271>; else goto <D.21272>;
          <D.21271>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 722, "(field->offset % sizeof(gpointer)) == 0");
          <D.21272>:
          size.22 = (unsigned int) size;
          if (pos >= size.22) goto <D.21277>; else goto <D.21274>;
          <D.21277>:
          max_size.23 = (unsigned int) max_size;
          if (pos > max_size.23) goto <D.21279>; else goto <D.21274>;
          <D.21279>:
          iftmp.21 = 1;
          goto <D.21275>;
          <D.21274>:
          iftmp.21 = 0;
          <D.21275>:
          D.21280 = iftmp.21 != 0;
          D.21281 = (long int) D.21280;
          D.21282 = __builtin_expect (D.21281, 0);
          if (D.21282 != 0) goto <D.21283>; else goto <D.21284>;
          <D.21283>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 724, "pos < size || pos <= max_size");
          <D.21284>:
          D.21285 = pos / 64;
          D.21286 = (long unsigned int) D.21285;
          D.21287 = D.21286 * 8;
          D.21288 = bitmap + D.21287;
          D.21286 = (long unsigned int) D.21285;
          D.21287 = D.21286 * 8;
          D.21288 = bitmap + D.21287;
          D.21289 = *D.21288;
          D.21290 = pos & 63;
          D.21291 = 1 << D.21290;
          D.21292 = D.21289 | D.21291;
          *D.21288 = D.21292;
          D.21293 = *max_set;
          D.21294 = (unsigned int) D.21293;
          D.21295 = MAX_EXPR <D.21294, pos>;
          D.21296 = (int) D.21295;
          *max_set = D.21296;
          goto <D.19269>;
          <D.19276>:
          D.21297 = mono_type_generic_inst_is_valuetype (type);
          if (D.21297 == 0) goto <D.21298>; else goto <D.21299>;
          <D.21298>:
          D.21259 = field->offset;
          D.21262 = (long unsigned int) D.21259;
          D.21267 = D.21262 & 7;
          D.21268 = D.21267 != 0;
          D.21269 = (long int) D.21268;
          D.21270 = __builtin_expect (D.21269, 0);
          if (D.21270 != 0) goto <D.21300>; else goto <D.21301>;
          <D.21300>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 730, "(field->offset % sizeof(gpointer)) == 0");
          <D.21301>:
          D.21302 = pos / 64;
          D.21303 = (long unsigned int) D.21302;
          D.21304 = D.21303 * 8;
          D.21305 = bitmap + D.21304;
          D.21303 = (long unsigned int) D.21302;
          D.21304 = D.21303 * 8;
          D.21305 = bitmap + D.21304;
          D.21306 = *D.21305;
          D.21290 = pos & 63;
          D.21291 = 1 << D.21290;
          D.21307 = D.21306 | D.21291;
          *D.21305 = D.21307;
          D.21293 = *max_set;
          D.21294 = (unsigned int) D.21293;
          D.21295 = MAX_EXPR <D.21294, pos>;
          D.21296 = (int) D.21295;
          *max_set = D.21296;
          goto <D.19269>;
          <D.21299>:
          <D.19277>:
          {
            struct MonoClass * fclass;

            D.21242 = field->type;
            fclass = mono_class_from_mono_type (D.21242);
            D.21308 = BIT_FIELD_REF <*fclass, 64, 256>;
            D.21309 = D.21308 & 68719476736;
            if (D.21309 != 0) goto <D.21310>; else goto <D.21311>;
            <D.21310>:
            D.21312 = pos + 4294967294;
            D.21313 = (int) D.21312;
            compute_class_bitmap (fclass, bitmap, size, D.21313, max_set, 0);
            <D.21311>:
            goto <D.19269>;
          }
          <D.19279>:
          <D.19280>:
          <D.19281>:
          <D.19282>:
          <D.19283>:
          <D.19284>:
          <D.19285>:
          <D.19286>:
          <D.19287>:
          <D.19288>:
          <D.19289>:
          <D.19290>:
          goto <D.19269>;
          <D.19291>:
          D.21265 = type->type;
          D.21266 = (int) D.21265;
          D.21314 = field->parent;
          D.21315 = mono_type_get_full_name (D.21314);
          D.21316 = field->name;
          monoeg_g_log (0B, 4, "compute_class_bitmap: Invalid type %x for field %s:%s\n", D.21266, D.21315, D.21316);
          <D.19292>:
          goto <D.19292>;
          <D.19269>:
        }
        <D.19264>:
        field = mono_class_get_fields (p, &iter);
        if (field != 0B) goto <D.19293>; else goto <D.19265>;
        <D.19265>:
        if (static_fields != 0) goto <D.19294>; else goto <D.21317>;
        <D.21317>:
      }
    finally
      {
        iter = {CLOBBER};
      }
  }
  p = p->parent;
  <D.19296>:
  if (p != 0B) goto <D.19295>; else goto <D.19294>;
  <D.19294>:
  D.21239 = bitmap;
  return D.21239;
}


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

  D.21323 = __builtin_object_size (__dest, 0);
  D.21322 = __builtin___memset_chk (__dest, __ch, __len, D.21323);
  return D.21322;
}


__attribute__((visibility ("hidden")))
mono_string_alloc (int length)
{
  struct MonoString * D.21325;
  struct MonoDomain * D.21326;

  D.21326 = mono_domain_get ();
  D.21325 = mono_string_new_size (D.21326, length);
  return D.21325;
}


__attribute__((visibility ("hidden")))
mono_class_compute_gc_descriptor (struct MonoClass * class)
{
  int gcj_inited.24;
  struct MonoMethodSignature * D.21331;
  struct MonoMethodSignature * D.21332;
  struct MonoMethodSignature * D.21333;
  struct MonoMethodSignature * D.21334;
  long unsigned int D.21335;
  long unsigned int D.21336;
  long unsigned int D.21339;
  struct MonoClass * D.21342;
  void * D.21345;
  unsigned char D.21347;
  struct MonoClass * D.21350;
  long unsigned int D.21351;
  long unsigned int D.21352;
  unsigned char D.21355;
  _Bool D.21356;
  int D.21357;
  void * D.21358;
  int D.21360;
  long unsigned int D.21361;
  long unsigned int D.21362;
  int D.21363;
  int D.21364;
  long unsigned int D.21365;
  void * D.21366;
  int max_set.25;
  int D.21371;
  int D.21372;
  long unsigned int D.21373;
  void * D.21374;
  int max_set;
  gsize * bitmap;
  gsize default_bitmap[4];
  static gboolean gcj_inited = 0;

  try
    {
      max_set = 0;
      default_bitmap = {};
      gcj_inited.24 = gcj_inited;
      if (gcj_inited.24 == 0) goto <D.21329>; else goto <D.21330>;
      <D.21329>:
      mono_loader_lock ();
      D.21331 = mono_create_icall_signature ("object ptr");
      mono_register_jit_icall (mono_object_new_ptrfree, "mono_object_new_ptrfree", D.21331, 0);
      D.21332 = mono_create_icall_signature ("object ptr");
      mono_register_jit_icall (mono_object_new_ptrfree_box, "mono_object_new_ptrfree_box", D.21332, 0);
      D.21333 = mono_create_icall_signature ("object ptr");
      mono_register_jit_icall (mono_object_new_fast, "mono_object_new_fast", D.21333, 0);
      D.21334 = mono_create_icall_signature ("object int");
      mono_register_jit_icall (mono_string_alloc, "mono_string_alloc", D.21334, 0);
      gcj_inited = 1;
      mono_loader_unlock ();
      <D.21330>:
      D.21335 = BIT_FIELD_REF <*class, 64, 256>;
      D.21336 = D.21335 & 9223372036854775808;
      if (D.21336 == 0) goto <D.21337>; else goto <D.21338>;
      <D.21337>:
      mono_class_init (class);
      <D.21338>:
      D.21335 = BIT_FIELD_REF <*class, 64, 256>;
      D.21339 = D.21335 & 274877906944;
      if (D.21339 != 0) goto <D.21340>; else goto <D.21341>;
      <D.21340>:
      return;
      <D.21341>:
      class->gc_descr_inited = 1;
      class->gc_descr = 0B;
      bitmap = &default_bitmap;
      D.21342 = mono_defaults.string_class;
      if (D.21342 == class) goto <D.21343>; else goto <D.21344>;
      <D.21343>:
      D.21345 = mono_gc_make_descr_for_string (bitmap, 2);
      class->gc_descr = D.21345;
      goto <D.21346>;
      <D.21344>:
      D.21347 = class->rank;
      if (D.21347 != 0) goto <D.21348>; else goto <D.21349>;
      <D.21348>:
      D.21350 = class->element_class;
      mono_class_compute_gc_descriptor (D.21350);
      D.21350 = class->element_class;
      D.21351 = BIT_FIELD_REF <*D.21350, 64, 256>;
      D.21352 = D.21351 & 1152921504606846976;
      if (D.21352 == 0) goto <D.21353>; else goto <D.21354>;
      <D.21353>:
      {
        gsize abm;

        try
          {
            abm = 1;
            D.21355 = class->byval_arg.type;
            D.21356 = D.21355 == 29;
            D.21357 = (int) D.21356;
            D.21358 = mono_gc_make_descr_for_array (D.21357, &abm, 1, 8);
            class->gc_descr = D.21358;
          }
        finally
          {
            abm = {CLOBBER};
          }
      }
      goto <D.21359>;
      <D.21354>:
      D.21350 = class->element_class;
      bitmap = compute_class_bitmap (D.21350, &default_bitmap, 256, -2, &max_set, 0);
      D.21355 = class->byval_arg.type;
      D.21356 = D.21355 == 29;
      D.21357 = (int) D.21356;
      D.21360 = mono_array_element_size (class);
      D.21361 = (long unsigned int) D.21360;
      D.21362 = D.21361 / 8;
      D.21363 = (int) D.21362;
      D.21364 = mono_array_element_size (class);
      D.21365 = (long unsigned int) D.21364;
      D.21366 = mono_gc_make_descr_for_array (D.21357, bitmap, D.21363, D.21365);
      class->gc_descr = D.21366;
      if (&default_bitmap != bitmap) goto <D.21367>; else goto <D.21368>;
      <D.21367>:
      monoeg_g_free (bitmap);
      <D.21368>:
      <D.21359>:
      goto <D.21369>;
      <D.21349>:
      bitmap = compute_class_bitmap (class, &default_bitmap, 256, 0, &max_set, 0);
      max_set.25 = max_set;
      D.21371 = max_set.25 + 1;
      D.21372 = class->instance_size;
      D.21373 = (long unsigned int) D.21372;
      D.21374 = mono_gc_make_descr_for_object (bitmap, D.21371, D.21373);
      class->gc_descr = D.21374;
      if (&default_bitmap != bitmap) goto <D.21375>; else goto <D.21376>;
      <D.21375>:
      monoeg_g_free (bitmap);
      <D.21376>:
      <D.21369>:
      <D.21346>:
    }
  finally
    {
      max_set = {CLOBBER};
      default_bitmap = {CLOBBER};
    }
}


mono_object_new_ptrfree_box (struct MonoVTable * vtable)
{
  struct MonoClass * D.21380;
  int D.21381;
  long unsigned int D.21382;
  struct MonoObject * D.21383;
  struct MonoObject * obj;

  D.21380 = vtable->klass;
  D.21381 = D.21380->instance_size;
  D.21382 = (long unsigned int) D.21381;
  obj = mono_gc_alloc_obj (vtable, D.21382);
  D.21383 = obj;
  return D.21383;
}


mono_object_new_ptrfree (struct MonoVTable * vtable)
{
  struct MonoClass * D.21385;
  int D.21386;
  long unsigned int D.21387;
  struct MonoObject * D.21388;
  struct MonoObject * obj;

  D.21385 = vtable->klass;
  D.21386 = D.21385->instance_size;
  D.21387 = (long unsigned int) D.21386;
  obj = mono_gc_alloc_obj (vtable, D.21387);
  D.21388 = obj;
  return D.21388;
}


__attribute__((visibility ("hidden")))
mono_method_get_imt_slot (struct MonoMethod * method)
{
  long unsigned int D.21390;
  long unsigned int D.21391;
  short unsigned int D.21394;
  int D.21395;
  long unsigned int D.21396;
  long unsigned int D.21397;
  struct MonoClass * D.21398;
  unsigned int D.21399;
  unsigned int D.21400;
  unsigned char D.21403;
  const char * D.21408;
  const char * D.21409;
  const char * D.21410;
  unsigned int D.21411;
  guint32 * D.21412;
  unsigned int D.21413;
  guint32 * D.21414;
  unsigned int D.21415;
  guint32 * D.21416;
  struct MonoType * D.21417;
  unsigned int D.21418;
  int D.21419;
  long unsigned int D.21420;
  long unsigned int D.21421;
  guint32 * D.21422;
  struct MonoType * D.21423;
  unsigned int D.21424;
  unsigned int hashes_count.26;
  unsigned int D.21426;
  unsigned int D.21427;
  unsigned int D.21428;
  unsigned int D.21429;
  unsigned int D.21430;
  unsigned int D.21431;
  unsigned int D.21432;
  unsigned int D.21433;
  unsigned int D.21434;
  unsigned int D.21435;
  unsigned int D.21436;
  unsigned int D.21437;
  unsigned int D.21438;
  unsigned int D.21439;
  unsigned int D.21440;
  unsigned int D.21441;
  guint32 D.21443;
  struct MonoMethodSignature * sig;
  int hashes_count;
  guint32 * hashes_start;
  guint32 * hashes;
  guint32 a;
  guint32 b;
  guint32 c;
  int i;

  D.21390 = BIT_FIELD_REF <*method, 64, 256>;
  D.21391 = D.21390 & 2251799813685248;
  if (D.21391 != 0) goto <D.21392>; else goto <D.21393>;
  <D.21392>:
  method = MEM[(struct MonoMethodInflated *)method].declaring;
  <D.21393>:
  sig = mono_method_signature (method);
  D.21394 = sig->param_count;
  D.21395 = (int) D.21394;
  hashes_count = D.21395 + 4;
  D.21396 = (long unsigned int) hashes_count;
  D.21397 = D.21396 * 4;
  hashes_start = malloc (D.21397);
  hashes = hashes_start;
  D.21398 = method->klass;
  D.21399 = D.21398->flags;
  D.21400 = D.21399 & 32;
  if (D.21400 == 0) goto <D.21401>; else goto <D.21402>;
  <D.21401>:
  D.21398 = method->klass;
  D.21403 = D.21398->byval_arg.type;
  if (D.21403 != 19) goto <D.21404>; else goto <D.21405>;
  <D.21404>:
  D.21398 = method->klass;
  D.21403 = D.21398->byval_arg.type;
  if (D.21403 != 30) goto <D.21406>; else goto <D.21407>;
  <D.21406>:
  D.21398 = method->klass;
  D.21408 = D.21398->name_space;
  D.21398 = method->klass;
  D.21409 = D.21398->name;
  D.21410 = method->name;
  monoeg_g_log (0B, 4, "mono_method_get_imt_slot: %s.%s.%s is not an interface MonoMethod", D.21408, D.21409, D.21410);
  <D.19337>:
  goto <D.19337>;
  <D.21407>:
  <D.21405>:
  <D.21402>:
  D.21398 = method->klass;
  D.21409 = D.21398->name;
  D.21411 = mono_metadata_str_hash (D.21409);
  *hashes = D.21411;
  D.21412 = hashes + 4;
  D.21398 = method->klass;
  D.21408 = D.21398->name_space;
  D.21413 = mono_metadata_str_hash (D.21408);
  *D.21412 = D.21413;
  D.21414 = hashes + 8;
  D.21410 = method->name;
  D.21415 = mono_metadata_str_hash (D.21410);
  *D.21414 = D.21415;
  D.21416 = hashes + 12;
  D.21417 = sig->ret;
  D.21418 = mono_metadata_type_hash (D.21417);
  *D.21416 = D.21418;
  i = 0;
  goto <D.19339>;
  <D.19338>:
  D.21419 = i + 4;
  D.21420 = (long unsigned int) D.21419;
  D.21421 = D.21420 * 4;
  D.21422 = hashes + D.21421;
  D.21423 = sig->params[i];
  D.21424 = mono_metadata_type_hash (D.21423);
  *D.21422 = D.21424;
  i = i + 1;
  <D.19339>:
  D.21394 = sig->param_count;
  D.21395 = (int) D.21394;
  if (D.21395 > i) goto <D.19338>; else goto <D.19340>;
  <D.19340>:
  hashes_count.26 = (unsigned int) hashes_count;
  D.21426 = hashes_count.26 << 2;
  c = D.21426 + 3735928559;
  b = c;
  a = b;
  goto <D.19342>;
  <D.19341>:
  D.21427 = *hashes;
  a = D.21427 + a;
  D.21412 = hashes + 4;
  D.21428 = *D.21412;
  b = D.21428 + b;
  D.21414 = hashes + 8;
  D.21429 = *D.21414;
  c = D.21429 + c;
  a = a - c;
  D.21430 = c r>> 28;
  a = D.21430 ^ a;
  c = c + b;
  b = b - a;
  D.21431 = a r>> 26;
  b = D.21431 ^ b;
  a = a + c;
  c = c - b;
  D.21432 = b r>> 24;
  c = D.21432 ^ c;
  b = b + a;
  a = a - c;
  D.21433 = c r>> 16;
  a = D.21433 ^ a;
  c = c + b;
  b = b - a;
  D.21434 = a r>> 13;
  b = D.21434 ^ b;
  a = a + c;
  c = c - b;
  D.21435 = b r>> 28;
  c = D.21435 ^ c;
  b = b + a;
  hashes_count = hashes_count + -3;
  hashes = hashes + 12;
  <D.19342>:
  if (hashes_count > 3) goto <D.19341>; else goto <D.19343>;
  <D.19343>:
  switch (hashes_count) <default: <D.21442>, case 0: <D.19347>, case 1: <D.19346>, case 2: <D.19345>, case 3: <D.19344>>
  <D.19344>:
  D.21414 = hashes + 8;
  D.21429 = *D.21414;
  c = D.21429 + c;
  <D.19345>:
  D.21412 = hashes + 4;
  D.21428 = *D.21412;
  b = D.21428 + b;
  <D.19346>:
  D.21427 = *hashes;
  a = D.21427 + a;
  c = c ^ b;
  D.21436 = b r>> 18;
  c = c - D.21436;
  a = a ^ c;
  D.21437 = c r>> 21;
  a = a - D.21437;
  b = b ^ a;
  D.21438 = a r>> 7;
  b = b - D.21438;
  c = c ^ b;
  D.21439 = b r>> 16;
  c = c - D.21439;
  a = a ^ c;
  D.21430 = c r>> 28;
  a = a - D.21430;
  b = b ^ a;
  D.21440 = a r>> 18;
  b = b - D.21440;
  c = c ^ b;
  D.21441 = b r>> 8;
  c = c - D.21441;
  <D.19347>:
  goto <D.19348>;
  <D.21442>:
  <D.19348>:
  free (hashes_start);
  D.21443 = c % 19;
  return D.21443;
}


__attribute__((visibility ("hidden")))
mono_vtable_build_imt_slot (struct MonoVTable * vtable, int imt_slot)
{
  unsigned int imt_slot.27;
  _Bool D.21446;
  long int D.21447;
  long int D.21448;
  struct MonoDomain * D.21451;
  union mono_mutex_t * D.21452;
  _Bool D.21455;
  long int D.21456;
  long int D.21457;
  long unsigned int D.21460;
  long unsigned int D.21461;
  void * * D.21462;
  void * D.21463;
  void * (*<T2695>) (int) D.21464;
  void * D.21465;
  struct MonoClass * D.21468;
  _Bool D.21471;
  long int D.21472;
  long int D.21473;
  void * * imt;

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

    D.21451 = vtable->domain;
    D.21452 = &D.21451->lock.mutex;
    ret = pthread_mutex_lock (D.21452);
    if (ret != 0) goto <D.21453>; else goto <D.21454>;
    <D.21453>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
    <D.21454>:
    D.21455 = ret != 0;
    D.21456 = (long int) D.21455;
    D.21457 = __builtin_expect (D.21456, 0);
    if (D.21457 != 0) goto <D.21458>; else goto <D.21459>;
    <D.21458>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 1460, "ret == 0");
    <D.21459>:
  }
  D.21460 = (long unsigned int) imt_slot;
  D.21461 = D.21460 * 8;
  D.21462 = imt + D.21461;
  D.21463 = *D.21462;
  D.21464 = callbacks.get_imt_trampoline;
  D.21465 = D.21464 (imt_slot);
  if (D.21463 == D.21465) goto <D.21466>; else goto <D.21467>;
  <D.21466>:
  D.21468 = vtable->klass;
  D.21451 = vtable->domain;
  build_imt_slots (D.21468, vtable, D.21451, imt, 0B, imt_slot);
  <D.21467>:
  {
    int ret;

    D.21451 = vtable->domain;
    D.21452 = &D.21451->lock.mutex;
    ret = pthread_mutex_unlock (D.21452);
    if (ret != 0) goto <D.21469>; else goto <D.21470>;
    <D.21469>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.21470>:
    D.21471 = ret != 0;
    D.21472 = (long int) D.21471;
    D.21473 = __builtin_expect (D.21472, 0);
    if (D.21473 != 0) goto <D.21474>; else goto <D.21475>;
    <D.21474>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 1464, "ret == 0");
    <D.21475>:
  }
  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.21476;
  long unsigned int D.21477;
  long unsigned int D.21478;
  struct MonoClass * * D.21479;
  guint16 * D.21480;
  long unsigned int D.21481;
  guint16 * D.21482;
  short unsigned int D.21483;
  int D.21484;
  long unsigned int D.21489;
  long unsigned int D.21490;
  struct MonoGenericClass * D.21493;
  struct MonoClass * D.21494;
  unsigned int D.21495;
  unsigned int slot_num.28;
  long unsigned int D.21499;
  long unsigned int D.21500;
  short unsigned int D.21503;
  int D.21504;
  int D.21505;
  unsigned int D.21508;
  unsigned int method_slot_in_interface.29;
  short unsigned int D.21510;
  int D.21511;
  int D.21514;
  unsigned int D.21515;
  unsigned int method_slot_in_interface.30;
  unsigned int interface_offset.31;
  unsigned int D.21518;
  void * * D.21522;
  struct MonoImtBuilderEntry * * D.21525;
  struct MonoImtBuilderEntry * D.21526;
  struct _MonoImtBuilderEntry * D.21529;
  int D.21530;
  int D.21531;
  int D.21532;
  int D.21533;
  int D.21538;
  unsigned int D.21539;
  unsigned int imt_collisions_bitmap.32;
  unsigned int imt_collisions_bitmap.33;
  void * iftmp.34;
  void * (*<T2695>) (int) D.21543;
  void * D.21547;
  void * D.21548;
  long unsigned int D.21551;
  long unsigned int D.21552;
  long unsigned int D.21555;
  long unsigned int D.21556;
  long unsigned int D.21557;
  unsigned int D.21560;
  unsigned int D.21561;
  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.19431>;
      <D.19430>:
      {
        struct MonoClass * iface;
        int interface_offset;
        int method_slot_in_interface;
        int vt_slot;

        D.21476 = klass->interfaces_packed;
        D.21477 = (long unsigned int) i;
        D.21478 = D.21477 * 8;
        D.21479 = D.21476 + D.21478;
        iface = *D.21479;
        D.21480 = klass->interface_offsets_packed;
        D.21477 = (long unsigned int) i;
        D.21481 = D.21477 * 2;
        D.21482 = D.21480 + D.21481;
        D.21483 = *D.21482;
        interface_offset = (int) D.21483;
        D.21484 = mono_class_has_variant_generic_params (iface);
        if (D.21484 != 0) goto <D.21485>; else goto <D.21486>;
        <D.21485>:
        has_variant_iface = 1;
        <D.21486>:
        mono_class_setup_methods (iface);
        vt_slot = interface_offset;
        method_slot_in_interface = 0;
        goto <D.19428>;
        <D.19427>:
        {
          struct MonoMethod * method;

          if (slot_num >= 0) goto <D.21487>; else goto <D.21488>;
          <D.21487>:
          D.21489 = BIT_FIELD_REF <*iface, 64, 256>;
          D.21490 = D.21489 & 268435456;
          if (D.21490 != 0) goto <D.21491>; else goto <D.21492>;
          <D.21491>:
          D.21493 = iface->generic_class;
          D.21494 = D.21493->container_class;
          method = mono_class_get_method_by_index (D.21494, method_slot_in_interface);
          D.21495 = mono_method_get_imt_slot (method);
          slot_num.28 = (unsigned int) slot_num;
          if (D.21495 != slot_num.28) goto <D.21497>; else goto <D.21498>;
          <D.21497>:
          vt_slot = vt_slot + 1;
          // predicted unlikely by continue predictor.
          goto <D.19426>;
          <D.21498>:
          <D.21492>:
          <D.21488>:
          method = mono_class_get_method_by_index (iface, method_slot_in_interface);
          D.21499 = BIT_FIELD_REF <*method, 64, 256>;
          D.21500 = D.21499 & 4503599627370496;
          if (D.21500 != 0) goto <D.21501>; else goto <D.21502>;
          <D.21501>:
          has_generic_virtual = 1;
          vt_slot = vt_slot + 1;
          // predicted unlikely by continue predictor.
          goto <D.19426>;
          <D.21502>:
          D.21503 = method->flags;
          D.21504 = (int) D.21503;
          D.21505 = D.21504 & 16;
          if (D.21505 == 0) goto <D.21506>; else goto <D.21507>;
          <D.21506>:
          add_imt_builder_entry (imt_builder, method, &imt_collisions_bitmap, vt_slot, slot_num);
          vt_slot = vt_slot + 1;
          <D.21507>:
        }
        <D.19426>:
        method_slot_in_interface = method_slot_in_interface + 1;
        <D.19428>:
        D.21508 = iface->method.count;
        method_slot_in_interface.29 = (unsigned int) method_slot_in_interface;
        if (D.21508 > method_slot_in_interface.29) goto <D.19427>; else goto <D.19429>;
        <D.19429>:
      }
      i = i + 1;
      <D.19431>:
      D.21510 = klass->interface_offsets_count;
      D.21511 = (int) D.21510;
      if (D.21511 > i) goto <D.19430>; else goto <D.19432>;
      <D.19432>:
      if (extra_interfaces != 0B) goto <D.21512>; else goto <D.21513>;
      <D.21512>:
      {
        int interface_offset;

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

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

            method = mono_class_get_method_by_index (iface, method_slot_in_interface);
            D.21514 = interface_offset + method_slot_in_interface;
            add_imt_builder_entry (imt_builder, method, &imt_collisions_bitmap, D.21514, slot_num);
          }
          method_slot_in_interface = method_slot_in_interface + 1;
          <D.19438>:
          D.21515 = iface->method.count;
          method_slot_in_interface.30 = (unsigned int) method_slot_in_interface;
          if (D.21515 > method_slot_in_interface.30) goto <D.19437>; else goto <D.19439>;
          <D.19439>:
          D.21515 = iface->method.count;
          interface_offset.31 = (unsigned int) interface_offset;
          D.21518 = D.21515 + interface_offset.31;
          interface_offset = (int) D.21518;
        }
        list_item = list_item->next;
        <D.19441>:
        if (list_item != 0B) goto <D.19440>; else goto <D.19442>;
        <D.19442>:
      }
      <D.21513>:
      i = 0;
      goto <D.19450>;
      <D.19449>:
      if (slot_num < 0) goto <D.21519>; else goto <D.21521>;
      <D.21521>:
      if (i == slot_num) goto <D.21519>; else goto <D.21520>;
      <D.21519>:
      {
        struct MonoImtBuilderEntry * entries;

        D.21477 = (long unsigned int) i;
        D.21478 = D.21477 * 8;
        D.21522 = imt + D.21478;
        entries = get_generic_virtual_entries (domain, D.21522);
        if (entries != 0B) goto <D.21523>; else goto <D.21524>;
        <D.21523>:
        D.21477 = (long unsigned int) i;
        D.21478 = D.21477 * 8;
        D.21525 = imt_builder + D.21478;
        D.21526 = *D.21525;
        if (D.21526 != 0B) goto <D.21527>; else goto <D.21528>;
        <D.21527>:
        {
          struct MonoImtBuilderEntry * entry;

          entry = entries;
          goto <D.19446>;
          <D.19445>:
          entry = entry->next;
          <D.19446>:
          D.21529 = entry->next;
          if (D.21529 != 0B) goto <D.19445>; else goto <D.19447>;
          <D.19447>:
          D.21477 = (long unsigned int) i;
          D.21478 = D.21477 * 8;
          D.21525 = imt_builder + D.21478;
          D.21526 = *D.21525;
          entry->next = D.21526;
          D.21530 = entries->children;
          D.21477 = (long unsigned int) i;
          D.21478 = D.21477 * 8;
          D.21525 = imt_builder + D.21478;
          D.21526 = *D.21525;
          D.21531 = D.21526->children;
          D.21532 = D.21531 + 1;
          D.21533 = D.21530 + D.21532;
          entries->children = D.21533;
        }
        <D.21528>:
        D.21477 = (long unsigned int) i;
        D.21478 = D.21477 * 8;
        D.21525 = imt_builder + D.21478;
        *D.21525 = entries;
        <D.21524>:
        if (has_generic_virtual != 0) goto <D.21534>; else goto <D.21537>;
        <D.21537>:
        if (has_variant_iface != 0) goto <D.21534>; else goto <D.21535>;
        <D.21534>:
        D.21538 = 1 << i;
        D.21539 = (unsigned int) D.21538;
        imt_collisions_bitmap.32 = imt_collisions_bitmap;
        imt_collisions_bitmap.33 = D.21539 | imt_collisions_bitmap.32;
        imt_collisions_bitmap = imt_collisions_bitmap.33;
        D.21477 = (long unsigned int) i;
        D.21478 = D.21477 * 8;
        D.21522 = imt + D.21478;
        D.21477 = (long unsigned int) i;
        D.21478 = D.21477 * 8;
        D.21525 = imt_builder + D.21478;
        D.21526 = *D.21525;
        D.21543 = callbacks.get_imt_trampoline;
        if (D.21543 != 0B) goto <D.21544>; else goto <D.21545>;
        <D.21544>:
        D.21543 = callbacks.get_imt_trampoline;
        iftmp.34 = D.21543 (i);
        goto <D.21546>;
        <D.21545>:
        iftmp.34 = 0B;
        <D.21546>:
        D.21547 = initialize_imt_slot (vt, domain, D.21526, iftmp.34);
        *D.21522 = D.21547;
        goto <D.21536>;
        <D.21535>:
        D.21477 = (long unsigned int) i;
        D.21478 = D.21477 * 8;
        D.21522 = imt + D.21478;
        D.21477 = (long unsigned int) i;
        D.21478 = D.21477 * 8;
        D.21525 = imt_builder + D.21478;
        D.21526 = *D.21525;
        D.21548 = initialize_imt_slot (vt, domain, D.21526, 0B);
        *D.21522 = D.21548;
        <D.21536>:
      }
      <D.21520>:
      D.21477 = (long unsigned int) i;
      D.21478 = D.21477 * 8;
      D.21525 = imt_builder + D.21478;
      D.21526 = *D.21525;
      if (D.21526 != 0B) goto <D.21549>; else goto <D.21550>;
      <D.21549>:
      {
        int methods_in_slot;

        D.21477 = (long unsigned int) i;
        D.21478 = D.21477 * 8;
        D.21525 = imt_builder + D.21478;
        D.21526 = *D.21525;
        D.21531 = D.21526->children;
        methods_in_slot = D.21531 + 1;
        D.21551 = (long unsigned int) methods_in_slot;
        D.21552 = mono_stats.imt_max_collisions_in_slot;
        if (D.21551 > D.21552) goto <D.21553>; else goto <D.21554>;
        <D.21553>:
        D.21551 = (long unsigned int) methods_in_slot;
        mono_stats.imt_max_collisions_in_slot = D.21551;
        record_method_count_for_max_collisions = 1;
        <D.21554>:
        method_count = method_count + methods_in_slot;
      }
      <D.21550>:
      i = i + 1;
      <D.19450>:
      if (i <= 18) goto <D.19449>; else goto <D.19451>;
      <D.19451>:
      D.21555 = mono_stats.imt_number_of_methods;
      D.21556 = (long unsigned int) method_count;
      D.21557 = D.21555 + D.21556;
      mono_stats.imt_number_of_methods = D.21557;
      if (record_method_count_for_max_collisions != 0) goto <D.21558>; else goto <D.21559>;
      <D.21558>:
      D.21556 = (long unsigned int) method_count;
      mono_stats.imt_method_count_when_max_collisions = D.21556;
      <D.21559>:
      i = 0;
      goto <D.19458>;
      <D.19457>:
      {
        struct MonoImtBuilderEntry * entry;

        D.21477 = (long unsigned int) i;
        D.21478 = D.21477 * 8;
        D.21525 = imt_builder + D.21478;
        entry = *D.21525;
        goto <D.19455>;
        <D.19454>:
        {
          struct MonoImtBuilderEntry * next;

          next = entry->next;
          monoeg_g_free (entry);
          entry = next;
        }
        <D.19455>:
        if (entry != 0B) goto <D.19454>; else goto <D.19456>;
        <D.19456>:
      }
      i = i + 1;
      <D.19458>:
      if (i <= 18) goto <D.19457>; else goto <D.19459>;
      <D.19459>:
      free (imt_builder);
      D.21560 = vt->imt_collisions_bitmap;
      imt_collisions_bitmap.32 = imt_collisions_bitmap;
      D.21561 = D.21560 | imt_collisions_bitmap.32;
      vt->imt_collisions_bitmap = D.21561;
    }
  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.35;
  long unsigned int D.21567;
  long unsigned int D.21568;
  struct MonoImtBuilderEntry * * D.21569;
  struct MonoImtBuilderEntry * D.21570;
  int D.21573;
  int D.21574;
  int D.21575;
  long unsigned int D.21578;
  long unsigned int D.21579;
  unsigned int D.21580;
  int D.21581;
  unsigned int D.21582;
  unsigned int D.21583;
  long unsigned int D.21585;
  long unsigned int D.21586;
  guint32 imt_slot;
  struct MonoImtBuilderEntry * entry;

  imt_slot = mono_method_get_imt_slot (method);
  if (slot_num >= 0) goto <D.21562>; else goto <D.21563>;
  <D.21562>:
  slot_num.35 = (unsigned int) slot_num;
  if (imt_slot != slot_num.35) goto <D.21565>; else goto <D.21566>;
  <D.21565>:
  return;
  <D.21566>:
  <D.21563>:
  entry = monoeg_malloc0 (32);
  entry->key = method;
  entry->value.vtable_slot = vtable_slot;
  D.21567 = (long unsigned int) imt_slot;
  D.21568 = D.21567 * 8;
  D.21569 = imt_builder + D.21568;
  D.21570 = *D.21569;
  entry->next = D.21570;
  D.21567 = (long unsigned int) imt_slot;
  D.21568 = D.21567 * 8;
  D.21569 = imt_builder + D.21568;
  D.21570 = *D.21569;
  if (D.21570 != 0B) goto <D.21571>; else goto <D.21572>;
  <D.21571>:
  D.21567 = (long unsigned int) imt_slot;
  D.21568 = D.21567 * 8;
  D.21569 = imt_builder + D.21568;
  D.21570 = *D.21569;
  D.21573 = D.21570->children;
  D.21574 = D.21573 + 1;
  entry->children = D.21574;
  D.21575 = entry->children;
  if (D.21575 == 1) goto <D.21576>; else goto <D.21577>;
  <D.21576>:
  D.21578 = mono_stats.imt_slots_with_collisions;
  D.21579 = D.21578 + 1;
  mono_stats.imt_slots_with_collisions = D.21579;
  D.21580 = *imt_collisions_bitmap;
  D.21581 = 1 << imt_slot;
  D.21582 = (unsigned int) D.21581;
  D.21583 = D.21580 | D.21582;
  *imt_collisions_bitmap = D.21583;
  <D.21577>:
  goto <D.21584>;
  <D.21572>:
  entry->children = 0;
  D.21585 = mono_stats.imt_used_slots;
  D.21586 = D.21585 + 1;
  mono_stats.imt_used_slots = D.21586;
  <D.21584>:
  D.21567 = (long unsigned int) imt_slot;
  D.21568 = D.21567 * 8;
  D.21569 = imt_builder + D.21568;
  *D.21569 = entry;
}


get_generic_virtual_entries (struct MonoDomain * domain, void * * vtable_slot)
{
  union mono_mutex_t * D.21588;
  _Bool D.21591;
  long int D.21592;
  long int D.21593;
  struct GHashTable * D.21596;
  struct GHashTable * D.21599;
  int D.21600;
  struct MonoMethod * D.21603;
  void * D.21604;
  void * D.21605;
  int D.21608;
  int D.21609;
  _Bool D.21612;
  long int D.21613;
  long int D.21614;
  struct MonoImtBuilderEntry * D.21617;
  struct GenericVirtualCase * list;
  struct MonoImtBuilderEntry * entries;

  {
    int ret;

    D.21588 = &domain->lock.mutex;
    ret = pthread_mutex_lock (D.21588);
    if (ret != 0) goto <D.21589>; else goto <D.21590>;
    <D.21589>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
    <D.21590>:
    D.21591 = ret != 0;
    D.21592 = (long int) D.21591;
    D.21593 = __builtin_expect (D.21592, 0);
    if (D.21593 != 0) goto <D.21594>; else goto <D.21595>;
    <D.21594>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 1645, "ret == 0");
    <D.21595>:
  }
  D.21596 = domain->generic_virtual_cases;
  if (D.21596 == 0B) goto <D.21597>; else goto <D.21598>;
  <D.21597>:
  D.21599 = monoeg_g_hash_table_new (mono_aligned_addr_hash, 0B);
  domain->generic_virtual_cases = D.21599;
  <D.21598>:
  D.21596 = domain->generic_virtual_cases;
  list = monoeg_g_hash_table_lookup (D.21596, vtable_slot);
  entries = 0B;
  goto <D.19535>;
  <D.19534>:
  {
    struct MonoImtBuilderEntry * entry;

    D.21600 = list->count;
    if (D.21600 <= 9) goto <D.21601>; else goto <D.21602>;
    <D.21601>:
    // predicted unlikely by continue predictor.
    goto <D.19533>;
    <D.21602>:
    entry = monoeg_malloc0 (32);
    D.21603 = list->method;
    entry->key = D.21603;
    D.21604 = list->code;
    D.21605 = mono_get_addr_from_ftnptr (D.21604);
    entry->value.target_code = D.21605;
    entry->has_target_code = 1;
    if (entries != 0B) goto <D.21606>; else goto <D.21607>;
    <D.21606>:
    D.21608 = entries->children;
    D.21609 = D.21608 + 1;
    entry->children = D.21609;
    <D.21607>:
    entry->next = entries;
    entries = entry;
  }
  <D.19533>:
  list = list->next;
  <D.19535>:
  if (list != 0B) goto <D.19534>; else goto <D.19536>;
  <D.19536>:
  {
    int ret;

    D.21588 = &domain->lock.mutex;
    ret = pthread_mutex_unlock (D.21588);
    if (ret != 0) goto <D.21610>; else goto <D.21611>;
    <D.21610>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.21611>:
    D.21612 = ret != 0;
    D.21613 = (long int) D.21612;
    D.21614 = __builtin_expect (D.21613, 0);
    if (D.21614 != 0) goto <D.21615>; else goto <D.21616>;
    <D.21615>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 1668, "ret == 0");
    <D.21616>:
  }
  D.21617 = entries;
  return D.21617;
}


initialize_imt_slot (struct MonoVTable * vtable, struct MonoDomain * domain, struct MonoImtBuilderEntry * imt_builder_entry, void * fail_tramp)
{
  int D.21622;
  void * D.21625;
  int D.21626;
  void * (*<T28cd>) (struct MonoVTable *, struct MonoDomain *, struct MonoIMTCheckItem * *, int, void *) imt_thunk_builder.36;
  void * * D.21628;
  unsigned int D.21629;
  int D.21630;
  long unsigned int D.21631;
  long unsigned int D.21632;
  void * * D.21633;
  void * D.21634;
  unsigned int i.37;

  if (imt_builder_entry != 0B) goto <D.21619>; else goto <D.21620>;
  <D.21619>:
  D.21622 = imt_builder_entry->children;
  if (D.21622 == 0) goto <D.21623>; else goto <D.21621>;
  <D.21623>:
  if (fail_tramp == 0B) goto <D.21624>; else goto <D.21621>;
  <D.21624>:
  D.21626 = imt_builder_entry->value.vtable_slot;
  D.21625 = vtable->vtable[D.21626];
  return D.21625;
  <D.21621>:
  {
    struct GPtrArray * imt_ir;
    void * result;
    int i;

    imt_ir = imt_sort_slot_entries (imt_builder_entry);
    imt_thunk_builder.36 = imt_thunk_builder;
    D.21628 = imt_ir->pdata;
    D.21629 = imt_ir->len;
    D.21630 = (int) D.21629;
    result = imt_thunk_builder.36 (vtable, domain, D.21628, D.21630, fail_tramp);
    i = 0;
    goto <D.19400>;
    <D.19399>:
    D.21628 = imt_ir->pdata;
    D.21631 = (long unsigned int) i;
    D.21632 = D.21631 * 8;
    D.21633 = D.21628 + D.21632;
    D.21634 = *D.21633;
    monoeg_g_free (D.21634);
    i = i + 1;
    <D.19400>:
    D.21629 = imt_ir->len;
    i.37 = (unsigned int) i;
    if (D.21629 > i.37) goto <D.19399>; else goto <D.19401>;
    <D.19401>:
    monoeg_g_ptr_array_free (imt_ir, 1);
    D.21625 = result;
    return D.21625;
  }
  <D.21620>:
  if (fail_tramp != 0B) goto <D.21636>; else goto <D.21637>;
  <D.21636>:
  D.21625 = fail_tramp;
  return D.21625;
  <D.21637>:
  D.21625 = 0B;
  return D.21625;
}


imt_sort_slot_entries (struct MonoImtBuilderEntry * entries)
{
  int D.21639;
  long unsigned int D.21640;
  long unsigned int D.21641;
  long unsigned int D.21642;
  long unsigned int D.21643;
  struct MonoImtBuilderEntry * * D.21644;
  long unsigned int D.21645;
  struct GPtrArray * D.21646;
  int number_of_entries;
  struct MonoImtBuilderEntry * * sorted_array;
  struct GPtrArray * result;
  struct MonoImtBuilderEntry * current_entry;
  int i;

  D.21639 = entries->children;
  number_of_entries = D.21639 + 1;
  D.21640 = (long unsigned int) number_of_entries;
  D.21641 = D.21640 * 8;
  sorted_array = malloc (D.21641);
  result = monoeg_g_ptr_array_new ();
  current_entry = entries;
  i = 0;
  goto <D.19388>;
  <D.19387>:
  D.21642 = (long unsigned int) i;
  D.21643 = D.21642 * 8;
  D.21644 = sorted_array + D.21643;
  *D.21644 = current_entry;
  current_entry = current_entry->next;
  i = i + 1;
  <D.19388>:
  if (current_entry != 0B) goto <D.19387>; else goto <D.19389>;
  <D.19389>:
  D.21645 = (long unsigned int) number_of_entries;
  qsort (sorted_array, D.21645, 8, compare_imt_builder_entries);
  imt_emit_ir (sorted_array, 0, number_of_entries, result);
  free (sorted_array);
  D.21646 = result;
  return D.21646;
}


compare_imt_builder_entries (const void * p1, const void * p2)
{
  int D.21648;
  int iftmp.38;
  void * D.21650;
  void * D.21651;
  _Bool D.21654;
  struct MonoImtBuilderEntry * e1;
  struct MonoImtBuilderEntry * e2;

  e1 = MEM[(struct MonoImtBuilderEntry * *)p1];
  e2 = MEM[(struct MonoImtBuilderEntry * *)p2];
  D.21650 = e1->key;
  D.21651 = e2->key;
  if (D.21650 >= D.21651) goto <D.21652>; else goto <D.21653>;
  <D.21652>:
  D.21650 = e1->key;
  D.21651 = e2->key;
  D.21654 = D.21650 > D.21651;
  iftmp.38 = (int) D.21654;
  goto <D.21655>;
  <D.21653>:
  iftmp.38 = -1;
  <D.21655>:
  D.21648 = iftmp.38;
  return D.21648;
}


imt_emit_ir (struct MonoImtBuilderEntry * * sorted_array, int start, int end, struct GPtrArray * out_array)
{
  unsigned int D.21657;
  long unsigned int D.21660;
  long unsigned int D.21661;
  struct MonoImtBuilderEntry * * D.21662;
  struct MonoImtBuilderEntry * D.21663;
  void * D.21664;
  <unnamed-unsigned:1> D.21665;
  unsigned char D.21666;
  int D.21667;
  unsigned int D.21670;
  int D.21671;
  int D.21674;
  long unsigned int D.21675;
  long unsigned int D.21676;
  struct MonoImtBuilderEntry * * D.21677;
  struct MonoImtBuilderEntry * D.21678;
  void * D.21679;
  int D.21680;
  int D.21681;
  int count;
  int chunk_start;

  count = end - start;
  D.21657 = out_array->len;
  chunk_start = (int) D.21657;
  if (count <= 3) goto <D.21658>; else goto <D.21659>;
  <D.21658>:
  {
    int i;

    i = start;
    goto <D.19375>;
    <D.19374>:
    {
      struct MonoIMTCheckItem * item;

      item = monoeg_malloc0 (48);
      D.21660 = (long unsigned int) i;
      D.21661 = D.21660 * 8;
      D.21662 = sorted_array + D.21661;
      D.21663 = *D.21662;
      D.21664 = D.21663->key;
      item->key = D.21664;
      D.21660 = (long unsigned int) i;
      D.21661 = D.21660 * 8;
      D.21662 = sorted_array + D.21661;
      D.21663 = *D.21662;
      item->value = D.21663->value;
      D.21660 = (long unsigned int) i;
      D.21661 = D.21660 * 8;
      D.21662 = sorted_array + D.21661;
      D.21663 = *D.21662;
      D.21665 = D.21663->has_target_code;
      D.21666 = (unsigned char) D.21665;
      item->has_target_code = D.21666;
      item->is_equals = 1;
      D.21667 = end + -1;
      if (D.21667 > i) goto <D.21668>; else goto <D.21669>;
      <D.21668>:
      D.21657 = out_array->len;
      D.21670 = D.21657 + 1;
      D.21671 = (int) D.21670;
      item->check_target_idx = D.21671;
      goto <D.21672>;
      <D.21669>:
      item->check_target_idx = 0;
      <D.21672>:
      monoeg_g_ptr_array_add (out_array, item);
    }
    i = i + 1;
    <D.19375>:
    if (i < end) goto <D.19374>; else goto <D.19376>;
    <D.19376>:
  }
  goto <D.21673>;
  <D.21659>:
  {
    int middle;
    struct MonoIMTCheckItem * item;

    D.21674 = count / 2;
    middle = D.21674 + start;
    item = monoeg_malloc0 (48);
    D.21675 = (long unsigned int) middle;
    D.21676 = D.21675 * 8;
    D.21677 = sorted_array + D.21676;
    D.21678 = *D.21677;
    D.21679 = D.21678->key;
    item->key = D.21679;
    item->is_equals = 0;
    monoeg_g_ptr_array_add (out_array, item);
    imt_emit_ir (sorted_array, start, middle, out_array);
    D.21680 = imt_emit_ir (sorted_array, middle, end, out_array);
    item->check_target_idx = D.21680;
  }
  <D.21673>:
  D.21681 = chunk_start;
  return D.21681;
}


__attribute__((visibility ("hidden")))
mono_method_alloc_generic_virtual_thunk (struct MonoDomain * domain, int size)
{
  unsigned int size.39;
  unsigned int D.21684;
  unsigned int size.40;
  struct MonoThunkFreeList * * D.21688;
  long unsigned int D.21689;
  long unsigned int D.21690;
  struct MonoThunkFreeList * D.21691;
  unsigned int D.21692;
  unsigned int size.41;
  struct _MonoThunkFreeList * D.21696;
  void * D.21697;
  struct MonoThunkFreeList * * D.21698;
  unsigned int D.21701;
  _Bool D.21702;
  long int D.21703;
  long int D.21704;
  struct _MonoThunkFreeList * D.21707;
  int inited.42;
  int generic_virtual_thunks_size.43;
  int generic_virtual_thunks_size.44;
  union mono_mutex_t * D.21713;
  _Bool D.21716;
  long int D.21717;
  long int D.21718;
  struct GHashTable * D.21721;
  struct GHashTable * D.21724;
  _Bool D.21727;
  long int D.21728;
  long int D.21729;
  static gboolean inited = 0;
  static int generic_virtual_thunks_size = 0;
  guint32 * p;
  int i;
  struct MonoThunkFreeList * * l;

  init_thunk_free_lists (domain);
  size.39 = (unsigned int) size;
  D.21684 = size.39 + 4;
  size = (int) D.21684;
  size.40 = (unsigned int) size;
  if (size.40 <= 15) goto <D.21686>; else goto <D.21687>;
  <D.21686>:
  size = 16;
  <D.21687>:
  i = list_index_for_size (size);
  D.21688 = domain->thunk_free_lists;
  D.21689 = (long unsigned int) i;
  D.21690 = D.21689 * 8;
  l = D.21688 + D.21690;
  goto <D.19496>;
  <D.19495>:
  D.21691 = *l;
  D.21692 = D.21691->size;
  size.41 = (unsigned int) size;
  if (D.21692 >= size.41) goto <D.21694>; else goto <D.21695>;
  <D.21694>:
  {
    struct MonoThunkFreeList * item;

    item = *l;
    D.21696 = item->next;
    *l = D.21696;
    D.21697 = item + 4;
    return D.21697;
  }
  <D.21695>:
  D.21691 = *l;
  l = &D.21691->next;
  <D.19496>:
  D.21691 = *l;
  if (D.21691 != 0B) goto <D.19495>; else goto <D.19497>;
  <D.19497>:
  goto <D.19499>;
  <D.19500>:
  {
    struct MonoThunkFreeList * item;

    D.21688 = domain->thunk_free_lists;
    D.21689 = (long unsigned int) i;
    D.21690 = D.21689 * 8;
    D.21698 = D.21688 + D.21690;
    item = *D.21698;
    if (item == 0B) goto <D.21699>; else goto <D.21700>;
    <D.21699>:
    // predicted unlikely by continue predictor.
    goto <D.19499>;
    <D.21700>:
    D.21701 = item->size;
    size.41 = (unsigned int) size;
    D.21702 = D.21701 <= size.41;
    D.21703 = (long int) D.21702;
    D.21704 = __builtin_expect (D.21703, 0);
    if (D.21704 != 0) goto <D.21705>; else goto <D.21706>;
    <D.21705>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 1550, "item->size > size");
    <D.21706>:
    D.21688 = domain->thunk_free_lists;
    D.21689 = (long unsigned int) i;
    D.21690 = D.21689 * 8;
    D.21698 = D.21688 + D.21690;
    D.21707 = item->next;
    *D.21698 = D.21707;
    D.21697 = item + 4;
    return D.21697;
  }
  <D.19499>:
  i = i + 1;
  if (i <= 11) goto <D.19500>; else goto <D.19501>;
  <D.19501>:
  inited.42 = inited;
  if (inited.42 == 0) goto <D.21709>; else goto <D.21710>;
  <D.21709>:
  mono_counters_register ("Generic virtual thunk bytes", 2048, &generic_virtual_thunks_size);
  inited = 1;
  <D.21710>:
  generic_virtual_thunks_size.43 = generic_virtual_thunks_size;
  generic_virtual_thunks_size.44 = generic_virtual_thunks_size.43 + size;
  generic_virtual_thunks_size = generic_virtual_thunks_size.44;
  p = mono_domain_code_reserve (domain, size);
  size.41 = (unsigned int) size;
  *p = size.41;
  {
    int ret;

    D.21713 = &domain->lock.mutex;
    ret = pthread_mutex_lock (D.21713);
    if (ret != 0) goto <D.21714>; else goto <D.21715>;
    <D.21714>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
    <D.21715>:
    D.21716 = ret != 0;
    D.21717 = (long int) D.21716;
    D.21718 = __builtin_expect (D.21717, 0);
    if (D.21718 != 0) goto <D.21719>; else goto <D.21720>;
    <D.21719>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 1566, "ret == 0");
    <D.21720>:
  }
  D.21721 = domain->generic_virtual_thunks;
  if (D.21721 == 0B) goto <D.21722>; else goto <D.21723>;
  <D.21722>:
  D.21724 = monoeg_g_hash_table_new (0B, 0B);
  domain->generic_virtual_thunks = D.21724;
  <D.21723>:
  D.21721 = domain->generic_virtual_thunks;
  monoeg_g_hash_table_insert_replace (D.21721, p, p, 0);
  {
    int ret;

    D.21713 = &domain->lock.mutex;
    ret = pthread_mutex_unlock (D.21713);
    if (ret != 0) goto <D.21725>; else goto <D.21726>;
    <D.21725>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.21726>:
    D.21727 = ret != 0;
    D.21728 = (long int) D.21727;
    D.21729 = __builtin_expect (D.21728, 0);
    if (D.21729 != 0) goto <D.21730>; else goto <D.21731>;
    <D.21730>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 1570, "ret == 0");
    <D.21731>:
  }
  D.21697 = p + 4;
  return D.21697;
}


init_thunk_free_lists (struct MonoDomain * domain)
{
  struct MonoThunkFreeList * * D.21733;
  void * D.21736;

  D.21733 = domain->thunk_free_lists;
  if (D.21733 != 0B) goto <D.21734>; else goto <D.21735>;
  <D.21734>:
  return;
  <D.21735>:
  D.21736 = mono_domain_alloc0 (domain, 96);
  domain->thunk_free_lists = D.21736;
}


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

  i = 2;
  size = 64;
  goto <D.19483>;
  <D.19482>:
  i = i + 1;
  size = size << 1;
  <D.19483>:
  if (item_size > size) goto <D.21738>; else goto <D.19484>;
  <D.21738>:
  if (i <= 10) goto <D.19482>; else goto <D.19484>;
  <D.19484>:
  D.21739 = i;
  return D.21739;
}


__attribute__((visibility ("hidden")))
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.21741;
  _Bool D.21744;
  long int D.21745;
  long int D.21746;
  struct GHashTable * D.21749;
  struct GHashTable * D.21752;
  struct MonoMethod * D.21753;
  void * D.21757;
  int inited.45;
  int num_added.46;
  int num_added.47;
  int D.21763;
  int D.21764;
  long int vtable_slot.48;
  long int vtable.49;
  long int D.21771;
  long int D.21772;
  void * (*<T2695>) (int) D.21773;
  void * iftmp.50;
  void * (*<T2695>) (int) D.21776;
  void *[0:] * D.21779;
  long int D.21780;
  long int D.21781;
  long int D.21782;
  int D.21783;
  void * (*<T28cd>) (struct MonoVTable *, struct MonoDomain *, struct MonoIMTCheckItem * *, int, void *) imt_thunk_builder.51;
  void * * D.21786;
  unsigned int D.21787;
  int D.21788;
  void * D.21789;
  long unsigned int D.21790;
  long unsigned int D.21791;
  void * * D.21792;
  void * D.21793;
  unsigned int i.52;
  _Bool D.21801;
  long int D.21802;
  long int D.21803;
  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.21741 = &domain->lock.mutex;
    ret = pthread_mutex_lock (D.21741);
    if (ret != 0) goto <D.21742>; else goto <D.21743>;
    <D.21742>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
    <D.21743>:
    D.21744 = ret != 0;
    D.21745 = (long int) D.21744;
    D.21746 = __builtin_expect (D.21745, 0);
    if (D.21746 != 0) goto <D.21747>; else goto <D.21748>;
    <D.21747>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 1699, "ret == 0");
    <D.21748>:
  }
  D.21749 = domain->generic_virtual_cases;
  if (D.21749 == 0B) goto <D.21750>; else goto <D.21751>;
  <D.21750>:
  D.21752 = monoeg_g_hash_table_new (mono_aligned_addr_hash, 0B);
  domain->generic_virtual_cases = D.21752;
  <D.21751>:
  D.21749 = domain->generic_virtual_cases;
  list = monoeg_g_hash_table_lookup (D.21749, vtable_slot);
  gvc = list;
  goto <D.19555>;
  <D.19554>:
  D.21753 = gvc->method;
  if (D.21753 == method) goto <D.19553>; else goto <D.21754>;
  <D.21754>:
  gvc = gvc->next;
  <D.19555>:
  if (gvc != 0B) goto <D.19554>; else goto <D.19553>;
  <D.19553>:
  if (gvc == 0B) goto <D.21755>; else goto <D.21756>;
  <D.21755>:
  gvc = mono_domain_alloc (domain, 32);
  gvc->method = method;
  gvc->code = code;
  gvc->count = 0;
  D.21749 = domain->generic_virtual_cases;
  D.21757 = monoeg_g_hash_table_lookup (D.21749, vtable_slot);
  gvc->next = D.21757;
  D.21749 = domain->generic_virtual_cases;
  monoeg_g_hash_table_insert_replace (D.21749, vtable_slot, gvc, 0);
  inited.45 = inited;
  if (inited.45 == 0) goto <D.21759>; else goto <D.21760>;
  <D.21759>:
  mono_counters_register ("Generic virtual cases", 2048, &num_added);
  inited = 1;
  <D.21760>:
  num_added.46 = num_added;
  num_added.47 = num_added.46 + 1;
  num_added = num_added.47;
  <D.21756>:
  D.21763 = gvc->count;
  D.21764 = D.21763 + 1;
  gvc->count = D.21764;
  D.21763 = gvc->count;
  if (D.21763 == 10) goto <D.21765>; else goto <D.21766>;
  <D.21765>:
  {
    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.21767>; else goto <D.21768>;
    <D.21767>:
    {
      int displacement;
      int imt_slot;

      vtable_slot.48 = (long int) vtable_slot;
      vtable.49 = (long int) vtable;
      D.21771 = vtable_slot.48 - vtable.49;
      D.21772 = D.21771 /[ex] 8;
      displacement = (int) D.21772;
      imt_slot = displacement + 19;
      D.21773 = callbacks.get_imt_trampoline;
      imt_trampoline = D.21773 (imt_slot);
      *vtable_slot = imt_trampoline;
    }
    goto <D.21774>;
    <D.21768>:
    D.21776 = callbacks.get_vtable_trampoline;
    if (D.21776 != 0B) goto <D.21777>; else goto <D.21778>;
    <D.21777>:
    D.21776 = callbacks.get_vtable_trampoline;
    vtable_slot.48 = (long int) vtable_slot;
    D.21779 = &vtable->vtable;
    D.21780 = (long int) D.21779;
    D.21781 = vtable_slot.48 - D.21780;
    D.21782 = D.21781 /[ex] 8;
    D.21783 = (int) D.21782;
    iftmp.50 = D.21776 (D.21783);
    goto <D.21784>;
    <D.21778>:
    iftmp.50 = 0B;
    <D.21784>:
    vtable_trampoline = iftmp.50;
    entries = get_generic_virtual_entries (domain, vtable_slot);
    sorted = imt_sort_slot_entries (entries);
    imt_thunk_builder.51 = imt_thunk_builder;
    D.21786 = sorted->pdata;
    D.21787 = sorted->len;
    D.21788 = (int) D.21787;
    D.21789 = imt_thunk_builder.51 (0B, domain, D.21786, D.21788, vtable_trampoline);
    *vtable_slot = D.21789;
    goto <D.19563>;
    <D.19562>:
    {
      struct MonoImtBuilderEntry * next;

      next = entries->next;
      monoeg_g_free (entries);
      entries = next;
    }
    <D.19563>:
    if (entries != 0B) goto <D.19562>; else goto <D.19564>;
    <D.19564>:
    i = 0;
    goto <D.19566>;
    <D.19565>:
    D.21786 = sorted->pdata;
    D.21790 = (long unsigned int) i;
    D.21791 = D.21790 * 8;
    D.21792 = D.21786 + D.21791;
    D.21793 = *D.21792;
    monoeg_g_free (D.21793);
    i = i + 1;
    <D.19566>:
    D.21787 = sorted->len;
    i.52 = (unsigned int) i;
    if (D.21787 > i.52) goto <D.19565>; else goto <D.19567>;
    <D.19567>:
    monoeg_g_ptr_array_free (sorted, 1);
    <D.21774>:
    if (old_thunk != vtable_trampoline) goto <D.21795>; else goto <D.21796>;
    <D.21795>:
    if (old_thunk != imt_trampoline) goto <D.21797>; else goto <D.21798>;
    <D.21797>:
    invalidate_generic_virtual_thunk (domain, old_thunk);
    <D.21798>:
    <D.21796>:
  }
  <D.21766>:
  {
    int ret;

    D.21741 = &domain->lock.mutex;
    ret = pthread_mutex_unlock (D.21741);
    if (ret != 0) goto <D.21799>; else goto <D.21800>;
    <D.21799>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.21800>:
    D.21801 = ret != 0;
    D.21802 = (long int) D.21801;
    D.21803 = __builtin_expect (D.21802, 0);
    if (D.21803 != 0) goto <D.21804>; else goto <D.21805>;
    <D.21804>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 1770, "ret == 0");
    <D.21805>:
  }
}


invalidate_generic_virtual_thunk (struct MonoDomain * domain, void * code)
{
  union mono_mutex_t * D.21806;
  _Bool D.21809;
  long int D.21810;
  long int D.21811;
  struct GHashTable * D.21814;
  struct GHashTable * D.21817;
  void * D.21818;
  _Bool D.21823;
  long int D.21824;
  long int D.21825;
  struct MonoThunkFreeList * * D.21830;
  struct _MonoThunkFreeList * D.21831;
  struct MonoThunkFreeList * D.21832;
  int D.21833;
  unsigned int D.21834;
  int D.21835;
  long unsigned int D.21836;
  long unsigned int D.21837;
  struct MonoThunkFreeList * * D.21838;
  struct MonoThunkFreeList * D.21839;
  int D.21841;
  struct MonoThunkFreeList * * D.21842;
  struct MonoThunkFreeList * D.21843;
  struct _MonoThunkFreeList * D.21846;
  int D.21847;
  _Bool D.21849;
  long int D.21850;
  long int D.21851;
  guint32 * p;
  struct MonoThunkFreeList * l;
  gboolean found;

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

    D.21806 = &domain->lock.mutex;
    ret = pthread_mutex_lock (D.21806);
    if (ret != 0) goto <D.21807>; else goto <D.21808>;
    <D.21807>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
    <D.21808>:
    D.21809 = ret != 0;
    D.21810 = (long int) D.21809;
    D.21811 = __builtin_expect (D.21810, 0);
    if (D.21811 != 0) goto <D.21812>; else goto <D.21813>;
    <D.21812>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 1585, "ret == 0");
    <D.21813>:
  }
  D.21814 = domain->generic_virtual_thunks;
  if (D.21814 == 0B) goto <D.21815>; else goto <D.21816>;
  <D.21815>:
  D.21817 = monoeg_g_hash_table_new (0B, 0B);
  domain->generic_virtual_thunks = D.21817;
  <D.21816>:
  D.21814 = domain->generic_virtual_thunks;
  D.21818 = monoeg_g_hash_table_lookup (D.21814, l);
  if (D.21818 != 0B) goto <D.21819>; else goto <D.21820>;
  <D.21819>:
  found = 1;
  <D.21820>:
  {
    int ret;

    D.21806 = &domain->lock.mutex;
    ret = pthread_mutex_unlock (D.21806);
    if (ret != 0) goto <D.21821>; else goto <D.21822>;
    <D.21821>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.21822>:
    D.21823 = ret != 0;
    D.21824 = (long int) D.21823;
    D.21825 = __builtin_expect (D.21824, 0);
    if (D.21825 != 0) goto <D.21826>; else goto <D.21827>;
    <D.21826>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 1590, "ret == 0");
    <D.21827>:
  }
  if (found == 0) goto <D.21828>; else goto <D.21829>;
  <D.21828>:
  return;
  <D.21829>:
  init_thunk_free_lists (domain);
  goto <D.19517>;
  <D.19516>:
  {
    struct MonoThunkFreeList * item;
    int length;
    int i;

    D.21830 = domain->thunk_free_lists;
    item = *D.21830;
    length = item->length;
    D.21830 = domain->thunk_free_lists;
    D.21831 = item->next;
    *D.21830 = D.21831;
    D.21830 = domain->thunk_free_lists;
    D.21832 = *D.21830;
    D.21833 = length + -1;
    D.21832->length = D.21833;
    D.21834 = item->size;
    D.21835 = (int) D.21834;
    i = list_index_for_size (D.21835);
    D.21830 = domain->thunk_free_lists;
    D.21836 = (long unsigned int) i;
    D.21837 = D.21836 * 8;
    D.21838 = D.21830 + D.21837;
    D.21839 = *D.21838;
    item->next = D.21839;
    D.21830 = domain->thunk_free_lists;
    D.21836 = (long unsigned int) i;
    D.21837 = D.21836 * 8;
    D.21838 = D.21830 + D.21837;
    *D.21838 = item;
  }
  <D.19517>:
  D.21830 = domain->thunk_free_lists;
  D.21832 = *D.21830;
  if (D.21832 != 0B) goto <D.21840>; else goto <D.19518>;
  <D.21840>:
  D.21830 = domain->thunk_free_lists;
  D.21832 = *D.21830;
  D.21841 = D.21832->length;
  if (D.21841 > 49) goto <D.19516>; else goto <D.19518>;
  <D.19518>:
  l->next = 0B;
  D.21830 = domain->thunk_free_lists;
  D.21842 = D.21830 + 8;
  D.21843 = *D.21842;
  if (D.21843 != 0B) goto <D.21844>; else goto <D.21845>;
  <D.21844>:
  D.21830 = domain->thunk_free_lists;
  D.21842 = D.21830 + 8;
  D.21830 = domain->thunk_free_lists;
  D.21842 = D.21830 + 8;
  D.21843 = *D.21842;
  D.21843->next = l;
  D.21846 = D.21843->next;
  *D.21842 = D.21846;
  D.21830 = domain->thunk_free_lists;
  D.21832 = *D.21830;
  D.21841 = D.21832->length;
  D.21847 = D.21841 + 1;
  D.21832->length = D.21847;
  goto <D.21848>;
  <D.21845>:
  D.21830 = domain->thunk_free_lists;
  D.21832 = *D.21830;
  D.21849 = D.21832 != 0B;
  D.21850 = (long int) D.21849;
  D.21851 = __builtin_expect (D.21850, 0);
  if (D.21851 != 0) goto <D.21852>; else goto <D.21853>;
  <D.21852>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 1618, "!domain->thunk_free_lists [0]");
  <D.21853>:
  D.21830 = domain->thunk_free_lists;
  D.21830 = domain->thunk_free_lists;
  D.21842 = D.21830 + 8;
  *D.21842 = l;
  D.21843 = *D.21842;
  *D.21830 = D.21843;
  D.21830 = domain->thunk_free_lists;
  D.21832 = *D.21830;
  D.21832->length = 1;
  <D.21848>:
}


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

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


__attribute__((visibility ("hidden")))
mono_class_vtable_full (struct MonoDomain * domain, struct MonoClass * class, gboolean raise_on_error)
{
  _Bool D.21857;
  long int D.21858;
  long int D.21859;
  unsigned char D.21862;
  struct MonoException * D.21867;
  struct MonoVTable * D.21868;
  short unsigned int D.21871;
  int D.21872;
  int D.21873;
  struct MonoVTable * D.21876;
  struct MonoClassRuntimeInfo * runtime_info;

  D.21857 = class == 0B;
  D.21858 = (long int) D.21857;
  D.21859 = __builtin_expect (D.21858, 0);
  if (D.21859 != 0) goto <D.21860>; else goto <D.21861>;
  <D.21860>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 1804, "class");
  <D.21861>:
  D.21862 = class->exception_type;
  if (D.21862 != 0) goto <D.21863>; else goto <D.21864>;
  <D.21863>:
  if (raise_on_error != 0) goto <D.21865>; else goto <D.21866>;
  <D.21865>:
  D.21867 = mono_class_get_exception_for_failure (class);
  mono_raise_exception (D.21867);
  <D.21866>:
  D.21868 = 0B;
  return D.21868;
  <D.21864>:
  runtime_info = class->runtime_info;
  if (runtime_info != 0B) goto <D.21869>; else goto <D.21870>;
  <D.21869>:
  D.21871 = runtime_info->max_domain;
  D.21872 = (int) D.21871;
  D.21873 = domain->domain_id;
  if (D.21872 >= D.21873) goto <D.21874>; else goto <D.21875>;
  <D.21874>:
  D.21873 = domain->domain_id;
  D.21876 = runtime_info->domain_vtables[D.21873];
  if (D.21876 != 0B) goto <D.21877>; else goto <D.21878>;
  <D.21877>:
  D.21873 = domain->domain_id;
  D.21868 = runtime_info->domain_vtables[D.21873];
  return D.21868;
  <D.21878>:
  <D.21875>:
  <D.21870>:
  D.21868 = mono_class_create_runtime_vtable (domain, class, raise_on_error);
  return D.21868;
}


mono_class_create_runtime_vtable (struct MonoDomain * domain, struct MonoClass * class, gboolean raise_on_error)
{
  union mono_mutex_t * D.21880;
  _Bool D.21883;
  long int D.21884;
  long int D.21885;
  short unsigned int D.21890;
  int D.21891;
  int D.21892;
  struct MonoVTable * D.21895;
  _Bool D.21900;
  long int D.21901;
  long int D.21902;
  struct MonoVTable * D.21905;
  long unsigned int D.21906;
  long unsigned int D.21907;
  int D.21912;
  unsigned char D.21914;
  _Bool D.21917;
  long int D.21918;
  long int D.21919;
  struct MonoException * D.21924;
  unsigned char D.21927;
  long unsigned int D.21929;
  long unsigned int D.21930;
  unsigned char D.21933;
  int D.21936;
  _Bool D.21945;
  long int D.21946;
  long int D.21947;
  struct MonoException * D.21952;
  int D.21953;
  struct MonoGenericClass * D.21956;
  struct MonoMethod * * D.21959;
  _Bool D.21966;
  long int D.21967;
  long int D.21968;
  struct MonoException * D.21973;
  int D.21974;
  void * (*<T28cd>) (struct MonoVTable *, struct MonoDomain *, struct MonoIMTCheckItem * *, int, void *) imt_thunk_builder.53;
  long unsigned int D.21980;
  long unsigned int D.21981;
  unsigned int D.21982;
  short unsigned int D.21983;
  long unsigned int D.21986;
  long unsigned int D.21987;
  long unsigned int D.21988;
  long unsigned int D.21989;
  short unsigned int D.21991;
  int D.21992;
  int D.21993;
  long unsigned int D.21994;
  long unsigned int D.21995;
  long unsigned int D.21996;
  unsigned int D.21997;
  long unsigned int D.21998;
  long unsigned int D.21999;
  long unsigned int D.22000;
  long unsigned int D.22001;
  long unsigned int D.22002;
  sizetype D.22005;
  sizetype D.22007;
  sizetype D.22008;
  sizetype D.22009;
  unsigned char D.22010;
  void * D.22011;
  unsigned int D.22012;
  int D.22013;
  _Bool D.22014;
  long int D.22015;
  long int D.22016;
  unsigned char D.22019;
  <unnamed-unsigned:4> D.22020;
  long unsigned int D.22023;
  int max_set.54;
  int D.22027;
  long unsigned int D.22028;
  void * D.22029;
  void * D.22030;
  void * D.22034;
  long unsigned int D.22035;
  long unsigned int D.22036;
  long unsigned int D.22037;
  struct MonoType * D.22038;
  short unsigned int D.22039;
  int D.22040;
  int D.22041;
  int D.22044;
  const char * D.22047;
  int D.22048;
  int D.22051;
  int iftmp.55;
  long unsigned int D.22055;
  int D.22061;
  int D.22065;
  int max_set.56;
  int D.22070;
  unsigned int special_static.57;
  int align.58;
  unsigned int align.59;
  struct GHashTable * D.22074;
  struct GHashTable * D.22077;
  long unsigned int D.22078;
  void * D.22079;
  int D.22082;
  signed short D.22085;
  _Bool D.22086;
  long int D.22087;
  long int D.22088;
  void * D.22091;
  int D.22092;
  sizetype D.22093;
  long unsigned int D.22096;
  long unsigned int D.22097;
  int D.22100;
  long unsigned int D.22101;
  int iftmp.60;
  unsigned char D.22106;
  _Bool D.22109;
  long int D.22110;
  long int D.22111;
  char D.22114;
  guint8 * D.22115;
  struct MonoClass * * D.22118;
  long unsigned int D.22119;
  long unsigned int D.22120;
  struct MonoClass * * D.22121;
  struct MonoClass * D.22122;
  short unsigned int D.22123;
  guint16 * D.22124;
  long unsigned int D.22125;
  guint16 * D.22126;
  short unsigned int D.22127;
  int D.22128;
  long unsigned int D.22129;
  long unsigned int D.22130;
  void * * D.22131;
  void * * D.22132;
  int D.22133;
  void * (*<T2695>) (int) D.22134;
  void * D.22137;
  struct MonoMethod * * D.22139;
  void * (*<T1f15>) (struct MonoMethod *) arch_create_jit_trampoline.61;
  void * D.22143;
  void * (*<T2695>) (int) D.22148;
  void * * D.22151;
  void * D.22152;
  struct MonoClass * D.22154;
  struct MonoType * D.22157;
  struct MonoReflectionType * D.22158;
  void * D.22159;
  struct MonoClass * D.22160;
  int D.22163;
  void * * D.22168;
  void * D.22169;
  long unsigned int D.22170;
  _Bool D.22171;
  struct GPtrArray * D.22172;
  short unsigned int D.22176;
  int D.22177;
  int D.22181;
  struct MonoImage * D.22182;
  long unsigned int D.22183;
  long unsigned int D.22184;
  unsigned int D.22185;
  unsigned int D.22186;
  short unsigned int D.22187;
  short unsigned int D.22188;
  struct MonoVTable *[0:] * D.22191;
  struct MonoVTable *[0:] * D.22192;
  int D.22193;
  long unsigned int D.22194;
  long unsigned int D.22195;
  struct MonoReflectionType * D.22198;
  struct MonoClass * D.22199;
  int D.22202;
  void * D.22207;
  _Bool D.22210;
  long int D.22211;
  long int D.22212;
  int D.22215;
  struct MonoException * D.22222;
  struct MonoClass * D.22223;
  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.21880 = &domain->lock.mutex;
        ret = pthread_mutex_lock (D.21880);
        if (ret != 0) goto <D.21881>; else goto <D.21882>;
        <D.21881>:
        monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
        <D.21882>:
        D.21883 = ret != 0;
        D.21884 = (long int) D.21883;
        D.21885 = __builtin_expect (D.21884, 0);
        if (D.21885 != 0) goto <D.21886>; else goto <D.21887>;
        <D.21886>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 1856, "ret == 0");
        <D.21887>:
      }
      runtime_info = class->runtime_info;
      if (runtime_info != 0B) goto <D.21888>; else goto <D.21889>;
      <D.21888>:
      D.21890 = runtime_info->max_domain;
      D.21891 = (int) D.21890;
      D.21892 = domain->domain_id;
      if (D.21891 >= D.21892) goto <D.21893>; else goto <D.21894>;
      <D.21893>:
      D.21892 = domain->domain_id;
      D.21895 = runtime_info->domain_vtables[D.21892];
      if (D.21895 != 0B) goto <D.21896>; else goto <D.21897>;
      <D.21896>:
      {
        int ret;

        D.21880 = &domain->lock.mutex;
        ret = pthread_mutex_unlock (D.21880);
        if (ret != 0) goto <D.21898>; else goto <D.21899>;
        <D.21898>:
        monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
        <D.21899>:
        D.21900 = ret != 0;
        D.21901 = (long int) D.21900;
        D.21902 = __builtin_expect (D.21901, 0);
        if (D.21902 != 0) goto <D.21903>; else goto <D.21904>;
        <D.21903>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 1859, "ret == 0");
        <D.21904>:
      }
      mono_loader_unlock ();
      D.21892 = domain->domain_id;
      D.21905 = runtime_info->domain_vtables[D.21892];
      return D.21905;
      <D.21897>:
      <D.21894>:
      <D.21889>:
      D.21906 = BIT_FIELD_REF <*class, 64, 256>;
      D.21907 = D.21906 & 9223372036871487488;
      if (D.21907 != 9223372036854775808) goto <D.21908>; else goto <D.21909>;
      <D.21908>:
      D.21912 = mono_class_init (class);
      if (D.21912 == 0) goto <D.21910>; else goto <D.21913>;
      <D.21913>:
      D.21914 = class->exception_type;
      if (D.21914 != 0) goto <D.21910>; else goto <D.21911>;
      <D.21910>:
      {
        int ret;

        D.21880 = &domain->lock.mutex;
        ret = pthread_mutex_unlock (D.21880);
        if (ret != 0) goto <D.21915>; else goto <D.21916>;
        <D.21915>:
        monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
        <D.21916>:
        D.21917 = ret != 0;
        D.21918 = (long int) D.21917;
        D.21919 = __builtin_expect (D.21918, 0);
        if (D.21919 != 0) goto <D.21920>; else goto <D.21921>;
        <D.21920>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 1865, "ret == 0");
        <D.21921>:
      }
      mono_loader_unlock ();
      if (raise_on_error != 0) goto <D.21922>; else goto <D.21923>;
      <D.21922>:
      D.21924 = mono_class_get_exception_for_failure (class);
      mono_raise_exception (D.21924);
      <D.21923>:
      D.21905 = 0B;
      return D.21905;
      <D.21911>:
      <D.21909>:
      D.21927 = class->byval_arg.type;
      if (D.21927 == 20) goto <D.21925>; else goto <D.21928>;
      <D.21928>:
      D.21927 = class->byval_arg.type;
      if (D.21927 == 29) goto <D.21925>; else goto <D.21926>;
      <D.21925>:
      {
        struct MonoClass * element_class;

        element_class = class->element_class;
        D.21929 = BIT_FIELD_REF <*element_class, 64, 256>;
        D.21930 = D.21929 & 9223372036854775808;
        if (D.21930 == 0) goto <D.21931>; else goto <D.21932>;
        <D.21931>:
        mono_class_init (element_class);
        <D.21932>:
        D.21933 = element_class->exception_type;
        if (D.21933 == 0) goto <D.21934>; else goto <D.21935>;
        <D.21934>:
        D.21936 = element_class->vtable_size;
        if (D.21936 == 0) goto <D.21937>; else goto <D.21938>;
        <D.21937>:
        mono_class_setup_vtable (element_class);
        <D.21938>:
        <D.21935>:
        D.21933 = element_class->exception_type;
        if (D.21933 != 0) goto <D.21939>; else goto <D.21940>;
        <D.21939>:
        D.21914 = class->exception_type;
        if (D.21914 == 0) goto <D.21941>; else goto <D.21942>;
        <D.21941>:
        mono_class_set_failure (class, 7, 0B);
        <D.21942>:
        {
          int ret;

          D.21880 = &domain->lock.mutex;
          ret = pthread_mutex_unlock (D.21880);
          if (ret != 0) goto <D.21943>; else goto <D.21944>;
          <D.21943>:
          monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
          <D.21944>:
          D.21945 = ret != 0;
          D.21946 = (long int) D.21945;
          D.21947 = __builtin_expect (D.21946, 0);
          if (D.21947 != 0) goto <D.21948>; else goto <D.21949>;
          <D.21948>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 1887, "ret == 0");
          <D.21949>:
        }
        mono_loader_unlock ();
        if (raise_on_error != 0) goto <D.21950>; else goto <D.21951>;
        <D.21950>:
        D.21952 = mono_class_get_exception_for_failure (class);
        mono_raise_exception (D.21952);
        <D.21951>:
        D.21905 = 0B;
        return D.21905;
        <D.21940>:
      }
      <D.21926>:
      D.21953 = class->vtable_size;
      if (D.21953 == 0) goto <D.21954>; else goto <D.21955>;
      <D.21954>:
      mono_class_setup_vtable (class);
      <D.21955>:
      D.21956 = class->generic_class;
      if (D.21956 != 0B) goto <D.21957>; else goto <D.21958>;
      <D.21957>:
      D.21959 = class->vtable;
      if (D.21959 == 0B) goto <D.21960>; else goto <D.21961>;
      <D.21960>:
      mono_class_check_vtable_constraints (class, 0B);
      <D.21961>:
      <D.21958>:
      mono_class_has_finalizer (class);
      D.21914 = class->exception_type;
      if (D.21914 != 0) goto <D.21962>; else goto <D.21963>;
      <D.21962>:
      {
        int ret;

        D.21880 = &domain->lock.mutex;
        ret = pthread_mutex_unlock (D.21880);
        if (ret != 0) goto <D.21964>; else goto <D.21965>;
        <D.21964>:
        monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
        <D.21965>:
        D.21966 = ret != 0;
        D.21967 = (long int) D.21966;
        D.21968 = __builtin_expect (D.21967, 0);
        if (D.21968 != 0) goto <D.21969>; else goto <D.21970>;
        <D.21969>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 1909, "ret == 0");
        <D.21970>:
      }
      mono_loader_unlock ();
      if (raise_on_error != 0) goto <D.21971>; else goto <D.21972>;
      <D.21971>:
      D.21973 = mono_class_get_exception_for_failure (class);
      mono_raise_exception (D.21973);
      <D.21972>:
      D.21905 = 0B;
      return D.21905;
      <D.21963>:
      vtable_slots = class->vtable_size;
      D.21974 = mono_class_data_size (class);
      class_size = (guint32) D.21974;
      if (class_size != 0) goto <D.21975>; else goto <D.21976>;
      <D.21975>:
      vtable_slots = vtable_slots + 1;
      <D.21976>:
      imt_thunk_builder.53 = imt_thunk_builder;
      if (imt_thunk_builder.53 != 0B) goto <D.21978>; else goto <D.21979>;
      <D.21978>:
      D.21980 = (long unsigned int) vtable_slots;
      D.21981 = D.21980 + 7;
      D.21982 = (unsigned int) D.21981;
      vtable_size = D.21982 * 8;
      D.21983 = class->interface_offsets_count;
      if (D.21983 != 0) goto <D.21984>; else goto <D.21985>;
      <D.21984>:
      imt_table_bytes = 152;
      vtable_size = vtable_size + 152;
      D.21986 = mono_stats.imt_number_of_tables;
      D.21987 = D.21986 + 1;
      mono_stats.imt_number_of_tables = D.21987;
      D.21988 = mono_stats.imt_tables_size;
      D.21989 = D.21988 + 152;
      mono_stats.imt_tables_size = D.21989;
      <D.21985>:
      goto <D.21990>;
      <D.21979>:
      D.21991 = class->max_interface_id;
      D.21992 = (int) D.21991;
      D.21993 = D.21992 + 1;
      D.21994 = (long unsigned int) D.21993;
      D.21980 = (long unsigned int) vtable_slots;
      D.21995 = D.21994 + D.21980;
      D.21996 = D.21995 + 7;
      D.21997 = (unsigned int) D.21996;
      vtable_size = D.21997 * 8;
      <D.21990>:
      D.21998 = mono_stats.used_class_count;
      D.21999 = D.21998 + 1;
      mono_stats.used_class_count = D.21999;
      D.22000 = mono_stats.class_vtable_size;
      D.22001 = (long unsigned int) vtable_size;
      D.22002 = D.22000 + D.22001;
      mono_stats.class_vtable_size = D.22002;
      interface_offsets = mono_domain_alloc0 (domain, vtable_size);
      imt_thunk_builder.53 = imt_thunk_builder;
      if (imt_thunk_builder.53 != 0B) goto <D.22003>; else goto <D.22004>;
      <D.22003>:
      D.22005 = (sizetype) imt_table_bytes;
      vt = interface_offsets + D.22005;
      goto <D.22006>;
      <D.22004>:
      D.21991 = class->max_interface_id;
      D.22007 = (sizetype) D.21991;
      D.22008 = D.22007 + 1;
      D.22009 = D.22008 * 8;
      vt = interface_offsets + D.22009;
      <D.22006>:
      vt->klass = class;
      D.22010 = class->rank;
      vt->rank = D.22010;
      vt->domain = domain;
      mono_class_compute_gc_descriptor (class);
      D.22011 = class->gc_descr;
      vt->gc_descr = D.22011;
      D.22012 = mono_gc_get_vtable_bits (class);
      gc_bits = (int) D.22012;
      D.22013 = gc_bits & -16;
      D.22014 = D.22013 != 0;
      D.22015 = (long int) D.22014;
      D.22016 = __builtin_expect (D.22015, 0);
      if (D.22016 != 0) goto <D.22017>; else goto <D.22018>;
      <D.22017>:
      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.22018>:
      D.22019 = (unsigned char) gc_bits;
      D.22020 = (<unnamed-unsigned:4>) D.22019;
      vt->gc_bits = D.22020;
      if (class_size != 0) goto <D.22021>; else goto <D.22022>;
      <D.22021>:
      D.21906 = BIT_FIELD_REF <*class, 64, 256>;
      D.22023 = D.21906 & 34359738368;
      if (D.22023 != 0) goto <D.22024>; else goto <D.22025>;
      <D.22024>:
      {
        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.54 = max_set;
            D.22027 = max_set.54 + 1;
            statics_gc_descr = mono_gc_make_descr_from_bitmap (bitmap, D.22027);
            D.21953 = class->vtable_size;
            D.22028 = (long unsigned int) class_size;
            D.22029 = mono_gc_alloc_fixed (D.22028, statics_gc_descr);
            vt->vtable[D.21953] = D.22029;
            D.21953 = class->vtable_size;
            D.22030 = vt->vtable[D.21953];
            mono_domain_add_class_static_data (domain, class, D.22030, 0B);
            if (&default_bitmap != bitmap) goto <D.22031>; else goto <D.22032>;
            <D.22031>:
            monoeg_g_free (bitmap);
            <D.22032>:
          }
        finally
          {
            max_set = {CLOBBER};
            default_bitmap = {CLOBBER};
          }
      }
      goto <D.22033>;
      <D.22025>:
      D.21953 = class->vtable_size;
      D.22034 = mono_domain_alloc0 (domain, class_size);
      vt->vtable[D.21953] = D.22034;
      <D.22033>:
      vt->has_static_fields = 1;
      D.22035 = mono_stats.class_static_data_size;
      D.22036 = (long unsigned int) class_size;
      D.22037 = D.22035 + D.22036;
      mono_stats.class_static_data_size = D.22037;
      <D.22022>:
      cindex = 4294967295;
      iter = 0B;
      goto <D.19617>;
      <D.19629>:
      D.22038 = field->type;
      D.22039 = D.22038->attrs;
      D.22040 = (int) D.22039;
      D.22041 = D.22040 & 16;
      if (D.22041 == 0) goto <D.22042>; else goto <D.22043>;
      <D.22042>:
      // predicted unlikely by continue predictor.
      goto <D.19617>;
      <D.22043>:
      D.22038 = field->type;
      D.22039 = D.22038->attrs;
      D.22040 = (int) D.22039;
      D.22044 = D.22040 & 1536;
      if (D.22044 != 0) goto <D.22045>; else goto <D.22046>;
      <D.22045>:
      D.22047 = mono_field_get_name (field);
      D.22048 = strcmp (D.22047, "_Deleted");
      if (D.22048 == 0) goto <D.22049>; else goto <D.22050>;
      <D.22049>:
      // predicted unlikely by continue predictor.
      goto <D.19617>;
      <D.22050>:
      <D.22046>:
      D.22038 = field->type;
      D.22039 = D.22038->attrs;
      D.22040 = (int) D.22039;
      D.22051 = D.22040 & 64;
      if (D.22051 == 0) goto <D.22052>; else goto <D.22053>;
      <D.22052>:
      {
        gint32 special_static;

        D.21906 = BIT_FIELD_REF <*class, 64, 256>;
        D.22055 = D.21906 & 17179869184;
        if (D.22055 == 0) goto <D.22056>; else goto <D.22057>;
        <D.22056>:
        iftmp.55 = field_is_special_static (class, field);
        goto <D.22058>;
        <D.22057>:
        iftmp.55 = 0;
        <D.22058>:
        special_static = iftmp.55;
        if (special_static != 0) goto <D.22059>; else goto <D.22060>;
        <D.22059>:
        {
          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.22038 = field->type;
              D.22061 = mono_type_is_reference (D.22038);
              if (D.22061 != 0) goto <D.22062>; else goto <D.22063>;
              <D.22062>:
              default_bitmap[0] = 1;
              numbits = 1;
              bitmap = &default_bitmap;
              goto <D.22064>;
              <D.22063>:
              D.22038 = field->type;
              D.22065 = mono_type_is_struct (D.22038);
              if (D.22065 != 0) goto <D.22066>; else goto <D.22067>;
              <D.22066>:
              D.22038 = field->type;
              fclass = mono_class_from_mono_type (D.22038);
              bitmap = compute_class_bitmap (fclass, &default_bitmap, 256, -2, &max_set, 0);
              max_set.56 = max_set;
              numbits = max_set.56 + 1;
              goto <D.22069>;
              <D.22067>:
              default_bitmap[0] = 0;
              numbits = 0;
              bitmap = &default_bitmap;
              <D.22069>:
              <D.22064>:
              D.22038 = field->type;
              D.22070 = mono_type_size (D.22038, &align);
              size = (guint32) D.22070;
              special_static.57 = (unsigned int) special_static;
              align.58 = align;
              align.59 = (unsigned int) align.58;
              offset = mono_alloc_special_static_data (special_static.57, size, align.59, bitmap, numbits);
              D.22074 = domain->special_static_fields;
              if (D.22074 == 0B) goto <D.22075>; else goto <D.22076>;
              <D.22075>:
              D.22077 = monoeg_g_hash_table_new (0B, 0B);
              domain->special_static_fields = D.22077;
              <D.22076>:
              D.22074 = domain->special_static_fields;
              D.22078 = (long unsigned int) offset;
              D.22079 = (void *) D.22078;
              monoeg_g_hash_table_insert_replace (D.22074, field, D.22079, 0);
              if (&default_bitmap != bitmap) goto <D.22080>; else goto <D.22081>;
              <D.22080>:
              monoeg_g_free (bitmap);
              <D.22081>:
              field->offset = -1;
              // predicted unlikely by continue predictor.
              goto <D.19617>;
            }
          finally
            {
              align = {CLOBBER};
              default_bitmap = {CLOBBER};
              max_set = {CLOBBER};
            }
        }
        <D.22060>:
      }
      <D.22053>:
      D.22038 = field->type;
      D.22039 = D.22038->attrs;
      D.22040 = (int) D.22039;
      D.22082 = D.22040 & 256;
      if (D.22082 != 0) goto <D.22083>; else goto <D.22084>;
      <D.22083>:
      {
        struct MonoClass * fklass;
        const char * data;

        D.22038 = field->type;
        fklass = mono_class_from_mono_type (D.22038);
        data = mono_field_get_data (field);
        D.22038 = field->type;
        D.22039 = D.22038->attrs;
        D.22085 = (signed short) D.22039;
        D.22086 = D.22085 < 0;
        D.22087 = (long int) D.22086;
        D.22088 = __builtin_expect (D.22087, 0);
        if (D.22088 != 0) goto <D.22089>; else goto <D.22090>;
        <D.22089>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 2043, "!(field->type->attrs & FIELD_ATTRIBUTE_HAS_DEFAULT)");
        <D.22090>:
        D.22091 = mono_vtable_get_static_field_data (vt);
        D.22092 = field->offset;
        D.22093 = (sizetype) D.22092;
        t = D.22091 + D.22093;
        if (data == 0B) goto <D.22094>; else goto <D.22095>;
        <D.22094>:
        // predicted unlikely by continue predictor.
        goto <D.19617>;
        <D.22095>:
        D.22096 = BIT_FIELD_REF <*fklass, 64, 256>;
        D.22097 = D.22096 & 1152921504606846976;
        if (D.22097 != 0) goto <D.22098>; else goto <D.22099>;
        <D.22098>:
        D.22100 = mono_class_value_size (fklass, 0B);
        D.22101 = (long unsigned int) D.22100;
        memcpy (t, data, D.22101);
        goto <D.22102>;
        <D.22099>:
        D.22106 = fklass->byval_arg.type;
        if (D.22106 != 15) goto <D.22107>; else goto <D.22104>;
        <D.22107>:
        D.22106 = fklass->byval_arg.type;
        if (D.22106 != 27) goto <D.22108>; else goto <D.22104>;
        <D.22108>:
        iftmp.60 = 1;
        goto <D.22105>;
        <D.22104>:
        iftmp.60 = 0;
        <D.22105>:
        D.22109 = iftmp.60 != 0;
        D.22110 = (long int) D.22109;
        D.22111 = __builtin_expect (D.22110, 0);
        if (D.22111 != 0) goto <D.22112>; else goto <D.22113>;
        <D.22112>:
        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.22113>:
        D.22114 = MEM[(char *)data];
        *t = D.22114;
        <D.22102>:
        // predicted unlikely by continue predictor.
        goto <D.19617>;
      }
      <D.22084>:
      <D.19617>:
      field = mono_class_get_fields (class, &iter);
      if (field != 0B) goto <D.19629>; else goto <D.19630>;
      <D.19630>:
      D.21991 = class->max_interface_id;
      vt->max_interface_id = D.21991;
      D.22115 = class->interface_bitmap;
      vt->interface_bitmap = D.22115;
      imt_thunk_builder.53 = imt_thunk_builder;
      if (imt_thunk_builder.53 == 0B) goto <D.22116>; else goto <D.22117>;
      <D.22116>:
      i = 0;
      goto <D.19634>;
      <D.19633>:
      {
        int interface_id;
        int slot;

        D.22118 = class->interfaces_packed;
        D.22119 = (long unsigned int) i;
        D.22120 = D.22119 * 8;
        D.22121 = D.22118 + D.22120;
        D.22122 = *D.22121;
        D.22123 = D.22122->interface_id;
        interface_id = (int) D.22123;
        D.22124 = class->interface_offsets_packed;
        D.22119 = (long unsigned int) i;
        D.22125 = D.22119 * 2;
        D.22126 = D.22124 + D.22125;
        D.22127 = *D.22126;
        slot = (int) D.22127;
        D.21991 = class->max_interface_id;
        D.21992 = (int) D.21991;
        D.22128 = D.21992 - interface_id;
        D.22129 = (long unsigned int) D.22128;
        D.22130 = D.22129 * 8;
        D.22131 = interface_offsets + D.22130;
        D.22132 = &vt->vtable[slot];
        *D.22131 = D.22132;
      }
      i = i + 1;
      <D.19634>:
      D.21983 = class->interface_offsets_count;
      D.22133 = (int) D.21983;
      if (D.22133 > i) goto <D.19633>; else goto <D.19635>;
      <D.19635>:
      <D.22117>:
      D.22134 = callbacks.get_vtable_trampoline;
      if (D.22134 != 0B) goto <D.22135>; else goto <D.22136>;
      <D.22135>:
      i = 0;
      goto <D.19637>;
      <D.19636>:
      D.22134 = callbacks.get_vtable_trampoline;
      D.22137 = D.22134 (i);
      vt->vtable[i] = D.22137;
      i = i + 1;
      <D.19637>:
      D.21953 = class->vtable_size;
      if (D.21953 > i) goto <D.19636>; else goto <D.19638>;
      <D.19638>:
      goto <D.22138>;
      <D.22136>:
      mono_class_setup_vtable (class);
      i = 0;
      goto <D.19641>;
      <D.19640>:
      {
        struct MonoMethod * cm;

        D.21959 = class->vtable;
        D.22119 = (long unsigned int) i;
        D.22120 = D.22119 * 8;
        D.22139 = D.21959 + D.22120;
        cm = *D.22139;
        if (cm != 0B) goto <D.22140>; else goto <D.22141>;
        <D.22140>:
        arch_create_jit_trampoline.61 = arch_create_jit_trampoline;
        D.22143 = arch_create_jit_trampoline.61 (cm);
        vt->vtable[i] = D.22143;
        <D.22141>:
      }
      i = i + 1;
      <D.19641>:
      D.21953 = class->vtable_size;
      if (D.21953 > i) goto <D.19640>; else goto <D.19642>;
      <D.19642>:
      <D.22138>:
      imt_thunk_builder.53 = imt_thunk_builder;
      if (imt_thunk_builder.53 != 0B) goto <D.22144>; else goto <D.22145>;
      <D.22144>:
      if (imt_table_bytes != 0) goto <D.22146>; else goto <D.22147>;
      <D.22146>:
      D.22148 = callbacks.get_imt_trampoline;
      if (D.22148 != 0B) goto <D.22149>; else goto <D.22150>;
      <D.22149>:
      i = 0;
      goto <D.19644>;
      <D.19643>:
      D.22119 = (long unsigned int) i;
      D.22120 = D.22119 * 8;
      D.22151 = interface_offsets + D.22120;
      D.22148 = callbacks.get_imt_trampoline;
      D.22152 = D.22148 (i);
      *D.22151 = D.22152;
      i = i + 1;
      <D.19644>:
      if (i <= 18) goto <D.19643>; else goto <D.19645>;
      <D.19645>:
      goto <D.22153>;
      <D.22150>:
      build_imt (class, vt, domain, interface_offsets, 0B);
      <D.22153>:
      <D.22147>:
      <D.22145>:
      D.22154 = mono_defaults.monotype_class;
      if (D.22154 != class) goto <D.22155>; else goto <D.22156>;
      <D.22155>:
      D.22157 = &class->byval_arg;
      D.22158 = mono_type_get_object (domain, D.22157);
      vt->type = D.22158;
      D.22159 = vt->type;
      D.22160 = mono_object_get_class (D.22159);
      D.22154 = mono_defaults.monotype_class;
      if (D.22160 != D.22154) goto <D.22161>; else goto <D.22162>;
      <D.22161>:
      D.22163 = mono_gc_is_moving ();
      if (D.22163 != 0) goto <D.22164>; else goto <D.22165>;
      <D.22164>:
      if (0 != 0) goto <D.22166>; else goto <D.22167>;
      <D.22166>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 2114, "sizeof (vt->type) == sizeof (MonoObject*)");
      <D.22167>:
      D.22168 = &vt->type;
      D.22169 = mono_gc_make_root_descr_all_refs (1);
      mono_gc_register_root (D.22168, 8, D.22169);
      <D.22165>:
      <D.22162>:
      <D.22156>:
      D.21906 = BIT_FIELD_REF <*class, 64, 256>;
      D.22170 = D.21906 & 1099511627776;
      D.22171 = D.22170 != 0;
      vt->remote = D.22171;
      D.22172 = domain->class_vtable_array;
      monoeg_g_ptr_array_add (D.22172, vt);
      mono_memory_barrier ();
      old_info = class->runtime_info;
      if (old_info != 0B) goto <D.22175>; else goto <D.22173>;
      <D.22175>:
      D.22176 = old_info->max_domain;
      D.22177 = (int) D.22176;
      D.21892 = domain->domain_id;
      if (D.22177 >= D.21892) goto <D.22178>; else goto <D.22173>;
      <D.22178>:
      D.21892 = domain->domain_id;
      old_info->domain_vtables[D.21892] = vt;
      goto <D.22174>;
      <D.22173>:
      {
        int new_size;

        new_size = domain->domain_id;
        if (old_info != 0B) goto <D.22179>; else goto <D.22180>;
        <D.22179>:
        D.22176 = old_info->max_domain;
        D.22181 = (int) D.22176;
        new_size = MAX_EXPR <D.22181, new_size>;
        <D.22180>:
        new_size = new_size + 1;
        i = 2;
        goto <D.19648>;
        <D.19647>:
        i = i << 1;
        <D.19648>:
        if (new_size > i) goto <D.19647>; else goto <D.19649>;
        <D.19649>:
        new_size = i;
        D.22182 = class->image;
        D.22183 = (long unsigned int) new_size;
        D.22184 = D.22183 + 1;
        D.22185 = (unsigned int) D.22184;
        D.22186 = D.22185 * 8;
        runtime_info = mono_image_alloc0 (D.22182, D.22186);
        D.22187 = (short unsigned int) new_size;
        D.22188 = D.22187 + 65535;
        runtime_info->max_domain = D.22188;
        if (old_info != 0B) goto <D.22189>; else goto <D.22190>;
        <D.22189>:
        D.22191 = &runtime_info->domain_vtables;
        D.22192 = &old_info->domain_vtables;
        D.22176 = old_info->max_domain;
        D.22181 = (int) D.22176;
        D.22193 = D.22181 + 1;
        D.22194 = (long unsigned int) D.22193;
        D.22195 = D.22194 * 8;
        memcpy (D.22191, D.22192, D.22195);
        <D.22190>:
        D.21892 = domain->domain_id;
        runtime_info->domain_vtables[D.21892] = vt;
        mono_memory_barrier ();
        class->runtime_info = runtime_info;
      }
      <D.22174>:
      D.22154 = mono_defaults.monotype_class;
      if (D.22154 == class) goto <D.22196>; else goto <D.22197>;
      <D.22196>:
      D.22157 = &class->byval_arg;
      D.22198 = mono_type_get_object (domain, D.22157);
      vt->type = D.22198;
      D.22159 = vt->type;
      D.22199 = mono_object_get_class (D.22159);
      D.22154 = mono_defaults.monotype_class;
      if (D.22199 != D.22154) goto <D.22200>; else goto <D.22201>;
      <D.22200>:
      D.22202 = mono_gc_is_moving ();
      if (D.22202 != 0) goto <D.22203>; else goto <D.22204>;
      <D.22203>:
      if (0 != 0) goto <D.22205>; else goto <D.22206>;
      <D.22205>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 2168, "sizeof (vt->type) == sizeof (MonoObject*)");
      <D.22206>:
      D.22168 = &vt->type;
      D.22207 = mono_gc_make_root_descr_all_refs (1);
      mono_gc_register_root (D.22168, 8, D.22207);
      <D.22204>:
      <D.22201>:
      <D.22197>:
      {
        int ret;

        D.21880 = &domain->lock.mutex;
        ret = pthread_mutex_unlock (D.21880);
        if (ret != 0) goto <D.22208>; else goto <D.22209>;
        <D.22208>:
        monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
        <D.22209>:
        D.22210 = ret != 0;
        D.22211 = (long int) D.22210;
        D.22212 = __builtin_expect (D.22211, 0);
        if (D.22212 != 0) goto <D.22213>; else goto <D.22214>;
        <D.22213>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 2171, "ret == 0");
        <D.22214>:
      }
      mono_loader_unlock ();
      D.22215 = mono_is_security_manager_active ();
      if (D.22215 != 0) goto <D.22216>; else goto <D.22217>;
      <D.22216>:
      D.21914 = class->exception_type;
      if (D.21914 == 2) goto <D.22218>; else goto <D.22219>;
      <D.22218>:
      if (raise_on_error != 0) goto <D.22220>; else goto <D.22221>;
      <D.22220>:
      D.22222 = mono_class_get_exception_for_failure (class);
      mono_raise_exception (D.22222);
      <D.22221>:
      <D.22219>:
      <D.22217>:
      D.22223 = class->parent;
      if (D.22223 != 0B) goto <D.22224>; else goto <D.22225>;
      <D.22224>:
      D.22223 = class->parent;
      mono_class_vtable_full (domain, D.22223, raise_on_error);
      <D.22225>:
      D.21905 = vt;
      return D.21905;
    }
  finally
    {
      iter = {CLOBBER};
    }
}


field_is_special_static (struct MonoClass * fklass, struct MonoClassField * field)
{
  gint32 D.22231;
  struct MonoMethod * D.22232;
  struct MonoImage * D.22233;
  struct MonoImage * D.22234;
  const char * D.22237;
  int D.22238;
  int D.22241;
  int D.22244;
  struct MonoCustomAttrInfo * ainfo;
  int i;

  ainfo = mono_custom_attrs_from_field (fklass, field);
  if (ainfo == 0B) goto <D.22229>; else goto <D.22230>;
  <D.22229>:
  D.22231 = 0;
  return D.22231;
  <D.22230>:
  i = 0;
  goto <D.19324>;
  <D.19323>:
  {
    struct MonoClass * klass;

    D.22232 = ainfo->attrs[i].ctor;
    klass = D.22232->klass;
    D.22233 = klass->image;
    D.22234 = mono_defaults.corlib;
    if (D.22233 == D.22234) goto <D.22235>; else goto <D.22236>;
    <D.22235>:
    D.22237 = klass->name;
    D.22238 = strcmp (D.22237, "ThreadStaticAttribute");
    if (D.22238 == 0) goto <D.22239>; else goto <D.22240>;
    <D.22239>:
    mono_custom_attrs_free (ainfo);
    D.22231 = 1;
    return D.22231;
    <D.22240>:
    D.22237 = klass->name;
    D.22241 = strcmp (D.22237, "ContextStaticAttribute");
    if (D.22241 == 0) goto <D.22242>; else goto <D.22243>;
    <D.22242>:
    mono_custom_attrs_free (ainfo);
    D.22231 = 2;
    return D.22231;
    <D.22243>:
    <D.22236>:
  }
  i = i + 1;
  <D.19324>:
  D.22244 = ainfo->num_attrs;
  if (D.22244 > i) goto <D.19323>; else goto <D.19325>;
  <D.19325>:
  mono_custom_attrs_free (ainfo);
  D.22231 = 0;
  return D.22231;
}


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);
}


__attribute__((visibility ("hidden")))
mono_class_try_get_vtable (struct MonoDomain * domain, struct MonoClass * class)
{
  _Bool D.22246;
  long int D.22247;
  long int D.22248;
  short unsigned int D.22253;
  int D.22254;
  int D.22255;
  struct MonoVTable * D.22258;
  struct MonoVTable * D.22261;
  struct MonoClassRuntimeInfo * runtime_info;

  D.22246 = class == 0B;
  D.22247 = (long int) D.22246;
  D.22248 = __builtin_expect (D.22247, 0);
  if (D.22248 != 0) goto <D.22249>; else goto <D.22250>;
  <D.22249>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 1832, "class");
  <D.22250>:
  runtime_info = class->runtime_info;
  if (runtime_info != 0B) goto <D.22251>; else goto <D.22252>;
  <D.22251>:
  D.22253 = runtime_info->max_domain;
  D.22254 = (int) D.22253;
  D.22255 = domain->domain_id;
  if (D.22254 >= D.22255) goto <D.22256>; else goto <D.22257>;
  <D.22256>:
  D.22255 = domain->domain_id;
  D.22258 = runtime_info->domain_vtables[D.22255];
  if (D.22258 != 0B) goto <D.22259>; else goto <D.22260>;
  <D.22259>:
  D.22255 = domain->domain_id;
  D.22261 = runtime_info->domain_vtables[D.22255];
  return D.22261;
  <D.22260>:
  <D.22257>:
  <D.22252>:
  D.22261 = 0B;
  return D.22261;
}


__attribute__((visibility ("hidden")))
mono_class_field_is_special_static (struct MonoClassField * field)
{
  struct MonoType * D.22263;
  short unsigned int D.22264;
  int D.22265;
  int D.22266;
  gboolean D.22269;
  int D.22270;
  const char * D.22273;
  int D.22274;
  int D.22277;
  struct MonoClass * D.22280;
  int D.22281;

  D.22263 = field->type;
  D.22264 = D.22263->attrs;
  D.22265 = (int) D.22264;
  D.22266 = D.22265 & 16;
  if (D.22266 == 0) goto <D.22267>; else goto <D.22268>;
  <D.22267>:
  D.22269 = 0;
  return D.22269;
  <D.22268>:
  D.22263 = field->type;
  D.22264 = D.22263->attrs;
  D.22265 = (int) D.22264;
  D.22270 = D.22265 & 1536;
  if (D.22270 != 0) goto <D.22271>; else goto <D.22272>;
  <D.22271>:
  D.22273 = mono_field_get_name (field);
  D.22274 = strcmp (D.22273, "_Deleted");
  if (D.22274 == 0) goto <D.22275>; else goto <D.22276>;
  <D.22275>:
  D.22269 = 0;
  return D.22269;
  <D.22276>:
  <D.22272>:
  D.22263 = field->type;
  D.22264 = D.22263->attrs;
  D.22265 = (int) D.22264;
  D.22277 = D.22265 & 64;
  if (D.22277 == 0) goto <D.22278>; else goto <D.22279>;
  <D.22278>:
  D.22280 = field->parent;
  D.22281 = field_is_special_static (D.22280, field);
  if (D.22281 != 0) goto <D.22282>; else goto <D.22283>;
  <D.22282>:
  D.22269 = 1;
  return D.22269;
  <D.22283>:
  <D.22279>:
  D.22269 = 0;
  return D.22269;
}


__attribute__((visibility ("hidden")))
mono_class_field_get_special_static_type (struct MonoClassField * field)
{
  struct MonoType * D.22285;
  short unsigned int D.22286;
  int D.22287;
  int D.22288;
  guint32 D.22291;
  int D.22292;
  const char * D.22295;
  int D.22296;
  int D.22299;
  struct MonoClass * D.22302;
  int D.22303;

  D.22285 = field->type;
  D.22286 = D.22285->attrs;
  D.22287 = (int) D.22286;
  D.22288 = D.22287 & 16;
  if (D.22288 == 0) goto <D.22289>; else goto <D.22290>;
  <D.22289>:
  D.22291 = 0;
  return D.22291;
  <D.22290>:
  D.22285 = field->type;
  D.22286 = D.22285->attrs;
  D.22287 = (int) D.22286;
  D.22292 = D.22287 & 1536;
  if (D.22292 != 0) goto <D.22293>; else goto <D.22294>;
  <D.22293>:
  D.22295 = mono_field_get_name (field);
  D.22296 = strcmp (D.22295, "_Deleted");
  if (D.22296 == 0) goto <D.22297>; else goto <D.22298>;
  <D.22297>:
  D.22291 = 0;
  return D.22291;
  <D.22298>:
  <D.22294>:
  D.22285 = field->type;
  D.22286 = D.22285->attrs;
  D.22287 = (int) D.22286;
  D.22299 = D.22287 & 64;
  if (D.22299 == 0) goto <D.22300>; else goto <D.22301>;
  <D.22300>:
  D.22302 = field->parent;
  D.22303 = field_is_special_static (D.22302, field);
  D.22291 = (guint32) D.22303;
  return D.22291;
  <D.22301>:
  D.22291 = 0;
  return D.22291;
}


__attribute__((visibility ("hidden")))
mono_class_has_special_static_fields (struct MonoClass * klass)
{
  struct MonoClass * D.22305;
  _Bool D.22306;
  long int D.22307;
  long int D.22308;
  int D.22311;
  gboolean D.22314;
  struct MonoClassField * field;
  void * iter;

  try
    {
      iter = 0B;
      goto <D.19726>;
      <D.19725>:
      D.22305 = field->parent;
      D.22306 = D.22305 != klass;
      D.22307 = (long int) D.22306;
      D.22308 = __builtin_expect (D.22307, 0);
      if (D.22308 != 0) goto <D.22309>; else goto <D.22310>;
      <D.22309>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 2420, "field->parent == klass");
      <D.22310>:
      D.22311 = mono_class_field_is_special_static (field);
      if (D.22311 != 0) goto <D.22312>; else goto <D.22313>;
      <D.22312>:
      D.22314 = 1;
      return D.22314;
      <D.22313>:
      <D.19726>:
      field = mono_class_get_fields (klass, &iter);
      if (field != 0B) goto <D.19725>; else goto <D.19727>;
      <D.19727>:
      D.22314 = 0;
      return D.22314;
    }
  finally
    {
      iter = {CLOBBER};
    }
}


__attribute__((visibility ("hidden")))
mono_remote_class (struct MonoDomain * domain, struct MonoString * class_name, struct MonoClass * proxy_class)
{
  union mono_mutex_t * D.22317;
  _Bool D.22320;
  long int D.22321;
  long int D.22322;
  struct GHashTable * D.22325;
  _Bool D.22330;
  long int D.22331;
  long int D.22332;
  struct MonoRemoteClass * D.22335;
  struct MonoMemPool * D.22336;
  int D.22337;
  _Bool D.22342;
  long int D.22343;
  long int D.22344;
  unsigned int D.22347;
  unsigned int D.22348;
  struct MonoClass * D.22351;
  int D.22353;
  int D.22354;
  struct MonoPerfCounters * mono_perfcounters.62;
  unsigned int D.22356;
  unsigned int D.22357;
  unsigned int D.22358;
  _Bool D.22361;
  long int D.22362;
  long int D.22363;
  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.22317 = &domain->lock.mutex;
        ret = pthread_mutex_lock (D.22317);
        if (ret != 0) goto <D.22318>; else goto <D.22319>;
        <D.22318>:
        monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
        <D.22319>:
        D.22320 = ret != 0;
        D.22321 = (long int) D.22320;
        D.22322 = __builtin_expect (D.22321, 0);
        if (D.22322 != 0) goto <D.22323>; else goto <D.22324>;
        <D.22323>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 2515, "ret == 0");
        <D.22324>:
      }
      D.22325 = domain->proxy_vtable_hash;
      rc = monoeg_g_hash_table_lookup (D.22325, key);
      if (rc != 0B) goto <D.22326>; else goto <D.22327>;
      <D.22326>:
      monoeg_g_free (key);
      {
        int ret;

        D.22317 = &domain->lock.mutex;
        ret = pthread_mutex_unlock (D.22317);
        if (ret != 0) goto <D.22328>; else goto <D.22329>;
        <D.22328>:
        monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
        <D.22329>:
        D.22330 = ret != 0;
        D.22331 = (long int) D.22330;
        D.22332 = __builtin_expect (D.22331, 0);
        if (D.22332 != 0) goto <D.22333>; else goto <D.22334>;
        <D.22333>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 2520, "ret == 0");
        <D.22334>:
      }
      D.22335 = rc;
      return D.22335;
      <D.22327>:
      D.22336 = domain->mp;
      name = mono_string_to_utf8_mp (D.22336, class_name, &error);
      D.22337 = mono_error_ok (&error);
      if (D.22337 == 0) goto <D.22338>; else goto <D.22339>;
      <D.22338>:
      monoeg_g_free (key);
      {
        int ret;

        D.22317 = &domain->lock.mutex;
        ret = pthread_mutex_unlock (D.22317);
        if (ret != 0) goto <D.22340>; else goto <D.22341>;
        <D.22340>:
        monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
        <D.22341>:
        D.22342 = ret != 0;
        D.22343 = (long int) D.22342;
        D.22344 = __builtin_expect (D.22343, 0);
        if (D.22344 != 0) goto <D.22345>; else goto <D.22346>;
        <D.22345>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 2527, "ret == 0");
        <D.22346>:
      }
      mono_error_raise_exception (&error);
      <D.22339>:
      mp_key = copy_remote_class_key (domain, key);
      monoeg_g_free (key);
      key = mp_key;
      D.22347 = proxy_class->flags;
      D.22348 = D.22347 & 32;
      if (D.22348 != 0) goto <D.22349>; else goto <D.22350>;
      <D.22349>:
      rc = mono_domain_alloc (domain, 48);
      rc->interface_count = 1;
      rc->interfaces[0] = proxy_class;
      D.22351 = mono_defaults.marshalbyrefobject_class;
      rc->proxy_class = D.22351;
      goto <D.22352>;
      <D.22350>:
      rc = mono_domain_alloc (domain, 40);
      rc->interface_count = 0;
      rc->proxy_class = proxy_class;
      <D.22352>:
      rc->default_vtable = 0B;
      rc->xdomain_vtable = 0B;
      rc->proxy_class_name = name;
      D.22353 = mono_string_length (class_name);
      D.22354 = D.22353 + 1;
      mono_perfcounters.62 = mono_perfcounters;
      mono_perfcounters.62 = mono_perfcounters;
      D.22356 = mono_perfcounters.62->loader_bytes;
      D.22357 = (unsigned int) D.22354;
      D.22358 = D.22356 + D.22357;
      mono_perfcounters.62->loader_bytes = D.22358;
      D.22325 = domain->proxy_vtable_hash;
      monoeg_g_hash_table_insert_replace (D.22325, key, rc, 0);
      {
        int ret;

        D.22317 = &domain->lock.mutex;
        ret = pthread_mutex_unlock (D.22317);
        if (ret != 0) goto <D.22359>; else goto <D.22360>;
        <D.22359>:
        monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
        <D.22360>:
        D.22361 = ret != 0;
        D.22362 = (long int) D.22361;
        D.22363 = __builtin_expect (D.22362, 0);
        if (D.22363 != 0) goto <D.22364>; else goto <D.22365>;
        <D.22364>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 2555, "ret == 0");
        <D.22365>:
      }
      D.22335 = rc;
      return D.22335;
    }
  finally
    {
      error = {CLOBBER};
    }
}


create_remote_class_key (struct MonoRemoteClass * remote_class, struct MonoClass * extra_class)
{
  unsigned int D.22370;
  unsigned int D.22371;
  void * * D.22374;
  struct MonoClass * D.22375;
  void * * D.22376;
  unsigned int D.22382;
  unsigned int D.22383;
  long unsigned int D.22384;
  long unsigned int D.22385;
  unsigned int D.22386;
  long int D.22387;
  void * D.22388;
  struct MonoClass * D.22389;
  struct MonoClass * D.22392;
  int j.63;
  long unsigned int D.22396;
  long unsigned int D.22397;
  void * * D.22398;
  long unsigned int D.22399;
  long unsigned int D.22400;
  void * * D.22401;
  unsigned int i.64;
  long unsigned int D.22405;
  long unsigned int D.22406;
  unsigned int D.22407;
  long int D.22408;
  void * D.22409;
  struct MonoClass * iftmp.65;
  int D.22414;
  long unsigned int D.22415;
  long unsigned int D.22416;
  void * * D.22417;
  void * * D.22418;
  void * * key;
  int i;
  int j;

  if (remote_class == 0B) goto <D.22368>; else goto <D.22369>;
  <D.22368>:
  D.22370 = extra_class->flags;
  D.22371 = D.22370 & 32;
  if (D.22371 != 0) goto <D.22372>; else goto <D.22373>;
  <D.22372>:
  key = monoeg_malloc (24);
  *key = 2B;
  D.22374 = key + 8;
  D.22375 = mono_defaults.marshalbyrefobject_class;
  *D.22374 = D.22375;
  D.22376 = key + 16;
  *D.22376 = extra_class;
  goto <D.22377>;
  <D.22373>:
  key = monoeg_malloc (16);
  *key = 1B;
  D.22374 = key + 8;
  *D.22374 = extra_class;
  <D.22377>:
  goto <D.22378>;
  <D.22369>:
  if (extra_class != 0B) goto <D.22380>; else goto <D.22379>;
  <D.22380>:
  D.22370 = extra_class->flags;
  D.22371 = D.22370 & 32;
  if (D.22371 != 0) goto <D.22381>; else goto <D.22379>;
  <D.22381>:
  D.22382 = remote_class->interface_count;
  D.22383 = D.22382 + 3;
  D.22384 = (long unsigned int) D.22383;
  D.22385 = D.22384 * 8;
  key = monoeg_malloc (D.22385);
  D.22382 = remote_class->interface_count;
  D.22386 = D.22382 + 2;
  D.22387 = (long int) D.22386;
  D.22388 = (void *) D.22387;
  *key = D.22388;
  D.22374 = key + 8;
  D.22389 = remote_class->proxy_class;
  *D.22374 = D.22389;
  i = 0;
  j = 2;
  goto <D.19736>;
  <D.19735>:
  if (extra_class != 0B) goto <D.22390>; else goto <D.22391>;
  <D.22390>:
  D.22392 = remote_class->interfaces[i];
  if (D.22392 > extra_class) goto <D.22393>; else goto <D.22394>;
  <D.22393>:
  j.63 = j;
  j = j.63 + 1;
  D.22396 = (long unsigned int) j.63;
  D.22397 = D.22396 * 8;
  D.22398 = key + D.22397;
  *D.22398 = extra_class;
  extra_class = 0B;
  <D.22394>:
  <D.22391>:
  D.22399 = (long unsigned int) j;
  D.22400 = D.22399 * 8;
  D.22401 = key + D.22400;
  D.22392 = remote_class->interfaces[i];
  *D.22401 = D.22392;
  i = i + 1;
  j = j + 1;
  <D.19736>:
  D.22382 = remote_class->interface_count;
  i.64 = (unsigned int) i;
  if (D.22382 > i.64) goto <D.19735>; else goto <D.19737>;
  <D.19737>:
  if (extra_class != 0B) goto <D.22403>; else goto <D.22404>;
  <D.22403>:
  D.22399 = (long unsigned int) j;
  D.22400 = D.22399 * 8;
  D.22401 = key + D.22400;
  *D.22401 = extra_class;
  <D.22404>:
  goto <D.19740>;
  <D.22379>:
  D.22382 = remote_class->interface_count;
  D.22386 = D.22382 + 2;
  D.22405 = (long unsigned int) D.22386;
  D.22406 = D.22405 * 8;
  key = monoeg_malloc (D.22406);
  D.22382 = remote_class->interface_count;
  D.22407 = D.22382 + 1;
  D.22408 = (long int) D.22407;
  D.22409 = (void *) D.22408;
  *key = D.22409;
  D.22374 = key + 8;
  if (extra_class == 0B) goto <D.22411>; else goto <D.22412>;
  <D.22411>:
  iftmp.65 = remote_class->proxy_class;
  goto <D.22413>;
  <D.22412>:
  iftmp.65 = extra_class;
  <D.22413>:
  *D.22374 = iftmp.65;
  i = 0;
  goto <D.19739>;
  <D.19738>:
  D.22414 = i + 2;
  D.22415 = (long unsigned int) D.22414;
  D.22416 = D.22415 * 8;
  D.22417 = key + D.22416;
  D.22392 = remote_class->interfaces[i];
  *D.22417 = D.22392;
  i = i + 1;
  <D.19739>:
  D.22382 = remote_class->interface_count;
  i.64 = (unsigned int) i;
  if (D.22382 > i.64) goto <D.19738>; else goto <D.19740>;
  <D.19740>:
  <D.22378>:
  D.22418 = key;
  return D.22418;
}


copy_remote_class_key (struct MonoDomain * domain, void * * key)
{
  void * D.22420;
  long int D.22421;
  unsigned int D.22422;
  unsigned int D.22423;
  unsigned int D.22424;
  unsigned int key_size.66;
  long unsigned int D.22426;
  void * * D.22427;
  int key_size;
  void * * mp_key;

  D.22420 = *key;
  D.22421 = (long int) D.22420;
  D.22422 = (unsigned int) D.22421;
  D.22423 = D.22422 + 1;
  D.22424 = D.22423 * 8;
  key_size = (int) D.22424;
  key_size.66 = (unsigned int) key_size;
  mp_key = mono_domain_alloc (domain, key_size.66);
  D.22426 = (long unsigned int) key_size;
  memcpy (mp_key, key, D.22426);
  D.22427 = mp_key;
  return D.22427;
}


__attribute__((visibility ("hidden")))
mono_remote_class_vtable (struct MonoDomain * domain, struct MonoRemoteClass * remote_class, struct MonoRealProxy * rp)
{
  union mono_mutex_t * D.22429;
  _Bool D.22432;
  long int D.22433;
  long int D.22434;
  int D.22437;
  struct MonoVTable * D.22440;
  struct MonoVTable * D.22443;
  _Bool D.22446;
  long int D.22447;
  long int D.22448;
  void * D.22451;
  struct MonoVTable * D.22452;
  struct MonoReflectionType * D.22455;
  long unsigned int D.22459;
  long unsigned int D.22460;
  struct MonoClass * D.22462;
  struct MonoClass * D.22464;
  struct MonoDomain * D.22465;
  struct MonoVTable * D.22466;
  long unsigned int D.22467;
  long unsigned int D.22468;
  struct MonoVTable * D.22470;
  struct MonoVTable * D.22471;
  _Bool D.22474;
  long int D.22475;
  long int D.22476;

  mono_loader_lock ();
  {
    int ret;

    D.22429 = &domain->lock.mutex;
    ret = pthread_mutex_lock (D.22429);
    if (ret != 0) goto <D.22430>; else goto <D.22431>;
    <D.22430>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
    <D.22431>:
    D.22432 = ret != 0;
    D.22433 = (long int) D.22432;
    D.22434 = __builtin_expect (D.22433, 0);
    if (D.22434 != 0) goto <D.22435>; else goto <D.22436>;
    <D.22435>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 2617, "ret == 0");
    <D.22436>:
  }
  D.22437 = rp->target_domain_id;
  if (D.22437 != -1) goto <D.22438>; else goto <D.22439>;
  <D.22438>:
  D.22440 = remote_class->xdomain_vtable;
  if (D.22440 == 0B) goto <D.22441>; else goto <D.22442>;
  <D.22441>:
  D.22443 = mono_class_proxy_vtable (domain, remote_class, 1);
  remote_class->xdomain_vtable = D.22443;
  <D.22442>:
  {
    int ret;

    D.22429 = &domain->lock.mutex;
    ret = pthread_mutex_unlock (D.22429);
    if (ret != 0) goto <D.22444>; else goto <D.22445>;
    <D.22444>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.22445>:
    D.22446 = ret != 0;
    D.22447 = (long int) D.22446;
    D.22448 = __builtin_expect (D.22447, 0);
    if (D.22448 != 0) goto <D.22449>; else goto <D.22450>;
    <D.22449>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 2621, "ret == 0");
    <D.22450>:
  }
  mono_loader_unlock ();
  D.22451 = remote_class->xdomain_vtable;
  return D.22451;
  <D.22439>:
  D.22452 = remote_class->default_vtable;
  if (D.22452 == 0B) goto <D.22453>; else goto <D.22454>;
  <D.22453>:
  {
    struct MonoType * type;
    struct MonoClass * klass;

    D.22455 = rp->class_to_proxy;
    type = D.22455->type;
    klass = mono_class_from_mono_type (type);
    D.22459 = BIT_FIELD_REF <*klass, 64, 256>;
    D.22460 = D.22459 & 8589934592;
    if (D.22460 != 0) goto <D.22456>; else goto <D.22461>;
    <D.22461>:
    D.22462 = mono_class_get_com_object_class ();
    if (D.22462 != 0B) goto <D.22463>; else goto <D.22457>;
    <D.22463>:
    D.22464 = mono_class_get_com_object_class ();
    if (D.22464 == klass) goto <D.22456>; else goto <D.22457>;
    <D.22456>:
    D.22465 = mono_domain_get ();
    D.22466 = mono_class_vtable (D.22465, klass);
    D.22467 = BIT_FIELD_REF <*D.22466, 64, 320>;
    D.22468 = D.22467 & 549755813888;
    if (D.22468 == 0) goto <D.22469>; else goto <D.22457>;
    <D.22469>:
    D.22470 = mono_class_proxy_vtable (domain, remote_class, 2);
    remote_class->default_vtable = D.22470;
    goto <D.22458>;
    <D.22457>:
    D.22471 = mono_class_proxy_vtable (domain, remote_class, 0);
    remote_class->default_vtable = D.22471;
    <D.22458>:
  }
  <D.22454>:
  {
    int ret;

    D.22429 = &domain->lock.mutex;
    ret = pthread_mutex_unlock (D.22429);
    if (ret != 0) goto <D.22472>; else goto <D.22473>;
    <D.22472>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.22473>:
    D.22474 = ret != 0;
    D.22475 = (long int) D.22474;
    D.22476 = __builtin_expect (D.22475, 0);
    if (D.22476 != 0) goto <D.22477>; else goto <D.22478>;
    <D.22477>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 2638, "ret == 0");
    <D.22478>:
  }
  mono_loader_unlock ();
  D.22451 = remote_class->default_vtable;
  return D.22451;
}


mono_class_proxy_vtable (struct MonoDomain * domain, struct MonoRemoteClass * remote_class, MonoRemotingTarget target_type)
{
  _Bool D.22480;
  long int D.22481;
  long int D.22482;
  short unsigned int D.22485;
  short unsigned int D.22486;
  short unsigned int D.22487;
  guint8 * D.22490;
  short unsigned int D.22491;
  sizetype D.22492;
  guint8 * D.22493;
  unsigned char D.22494;
  int D.22495;
  int D.22496;
  int D.22497;
  int D.22498;
  int D.22499;
  struct GSList * D.22502;
  int D.22505;
  _Bool D.22506;
  long int D.22507;
  long int D.22508;
  void * * D.22513;
  long unsigned int D.22514;
  long unsigned int D.22515;
  void * * D.22516;
  short unsigned int D.22517;
  short unsigned int D.22520;
  sizetype D.22521;
  guint8 * D.22522;
  unsigned char D.22523;
  int D.22524;
  int D.22525;
  int D.22526;
  int D.22527;
  int D.22528;
  struct GSList * D.22531;
  int D.22534;
  unsigned int D.22535;
  unsigned int i.67;
  long unsigned int D.22537;
  unsigned int D.22538;
  unsigned int D.22539;
  unsigned int extra_interface_vtsize.68;
  unsigned int D.22541;
  short unsigned int D.22542;
  int D.22543;
  unsigned int D.22546;
  unsigned int j.69;
  void * (*<T28cd>) (struct MonoVTable *, struct MonoDomain *, struct MonoIMTCheckItem * *, int, void *) imt_thunk_builder.70;
  long unsigned int D.22551;
  long unsigned int D.22552;
  long unsigned int D.22553;
  long unsigned int D.22554;
  int D.22555;
  long unsigned int D.22556;
  long unsigned int D.22557;
  unsigned int D.22558;
  unsigned int D.22559;
  int D.22561;
  long unsigned int D.22562;
  long unsigned int D.22563;
  long unsigned int D.22564;
  unsigned int D.22565;
  unsigned int D.22566;
  long unsigned int D.22567;
  int D.22568;
  long unsigned int D.22569;
  long unsigned int D.22570;
  unsigned int D.22571;
  sizetype D.22575;
  sizetype D.22576;
  sizetype D.22577;
  long unsigned int D.22578;
  long unsigned int D.22579;
  struct MonoClass * D.22580;
  void * D.22581;
  struct MonoMethod * * D.22582;
  struct MonoMethod * * D.22583;
  void * (*<T1f1e>) (struct MonoDomain *, struct MonoMethod *, MonoRemotingTarget) arch_create_remoting_trampoline.71;
  void * D.22587;
  unsigned int D.22589;
  unsigned int D.22590;
  short int D.22593;
  int D.22594;
  void * D.22595;
  void * D.22598;
  short unsigned int D.22599;
  int D.22600;
  unsigned int bsize.72;
  struct MonoClass * * D.22604;
  struct MonoClass * * D.22605;
  struct MonoClass * D.22606;
  short unsigned int D.22607;
  guint16 * D.22608;
  long unsigned int D.22609;
  guint16 * D.22610;
  short unsigned int D.22611;
  int D.22612;
  int D.22613;
  long unsigned int D.22614;
  long unsigned int D.22615;
  void * * D.22616;
  void * * D.22617;
  short unsigned int D.22618;
  int D.22619;
  int D.22620;
  sizetype D.22621;
  uint8_t * D.22622;
  unsigned char D.22623;
  signed char D.22624;
  int D.22625;
  int D.22626;
  signed char D.22627;
  signed char D.22628;
  unsigned char D.22629;
  short unsigned int D.22634;
  int D.22635;
  int D.22636;
  long unsigned int D.22637;
  long unsigned int D.22638;
  void * * D.22639;
  void * * D.22640;
  short unsigned int D.22641;
  sizetype D.22642;
  uint8_t * D.22643;
  unsigned char D.22644;
  signed char D.22645;
  int D.22646;
  int D.22647;
  signed char D.22648;
  signed char D.22649;
  unsigned char D.22650;
  int j.73;
  int D.22652;
  void * D.22653;
  int D.22654;
  struct MonoVTable * D.22661;
  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.22480 = vt == 0B;
      D.22481 = (long int) D.22480;
      D.22482 = __builtin_expect (D.22481, 0);
      if (D.22482 != 0) goto <D.22483>; else goto <D.22484>;
      <D.22483>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 2215, "vt");
      <D.22484>:
      D.22485 = vt->max_interface_id;
      max_interface_id = (int) D.22485;
      j = 0;
      goto <D.19680>;
      <D.19679>:
      {
        struct MonoClass * iclass;
        struct GPtrArray * ifaces;
        int method_count;

        iclass = remote_class->interfaces[j];
        D.22486 = iclass->interface_id;
        D.22487 = class->max_interface_id;
        if (D.22486 <= D.22487) goto <D.22488>; else goto <D.22489>;
        <D.22488>:
        D.22490 = class->interface_bitmap;
        D.22486 = iclass->interface_id;
        D.22491 = D.22486 >> 3;
        D.22492 = (sizetype) D.22491;
        D.22493 = D.22490 + D.22492;
        D.22494 = *D.22493;
        D.22495 = (int) D.22494;
        D.22486 = iclass->interface_id;
        D.22496 = (int) D.22486;
        D.22497 = D.22496 & 7;
        D.22498 = D.22495 >> D.22497;
        D.22499 = D.22498 & 1;
        if (D.22499 != 0) goto <D.22500>; else goto <D.22501>;
        <D.22500>:
        // predicted unlikely by continue predictor.
        goto <D.19673>;
        <D.22501>:
        <D.22489>:
        D.22502 = monoeg_g_slist_find (extra_interfaces, iclass);
        if (D.22502 != 0B) goto <D.22503>; else goto <D.22504>;
        <D.22503>:
        // predicted unlikely by continue predictor.
        goto <D.19673>;
        <D.22504>:
        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.22505 = mono_error_ok (&error);
        D.22506 = D.22505 == 0;
        D.22507 = (long int) D.22506;
        D.22508 = __builtin_expect (D.22507, 0);
        if (D.22508 != 0) goto <D.22509>; else goto <D.22510>;
        <D.22509>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 2235, "mono_error_ok (&error)");
        <D.22510>:
        if (ifaces != 0B) goto <D.22511>; else goto <D.22512>;
        <D.22511>:
        i = 0;
        goto <D.19677>;
        <D.19676>:
        {
          struct MonoClass * ic;

          D.22513 = ifaces->pdata;
          D.22514 = (long unsigned int) i;
          D.22515 = D.22514 * 8;
          D.22516 = D.22513 + D.22515;
          ic = *D.22516;
          D.22517 = ic->interface_id;
          D.22487 = class->max_interface_id;
          if (D.22517 <= D.22487) goto <D.22518>; else goto <D.22519>;
          <D.22518>:
          D.22490 = class->interface_bitmap;
          D.22517 = ic->interface_id;
          D.22520 = D.22517 >> 3;
          D.22521 = (sizetype) D.22520;
          D.22522 = D.22490 + D.22521;
          D.22523 = *D.22522;
          D.22524 = (int) D.22523;
          D.22517 = ic->interface_id;
          D.22525 = (int) D.22517;
          D.22526 = D.22525 & 7;
          D.22527 = D.22524 >> D.22526;
          D.22528 = D.22527 & 1;
          if (D.22528 != 0) goto <D.22529>; else goto <D.22530>;
          <D.22529>:
          // predicted unlikely by continue predictor.
          goto <D.19675>;
          <D.22530>:
          <D.22519>:
          D.22531 = monoeg_g_slist_find (extra_interfaces, ic);
          if (D.22531 != 0B) goto <D.22532>; else goto <D.22533>;
          <D.22532>:
          // predicted unlikely by continue predictor.
          goto <D.19675>;
          <D.22533>:
          extra_interfaces = monoeg_g_slist_prepend (extra_interfaces, ic);
          D.22534 = mono_class_num_methods (ic);
          method_count = D.22534 + method_count;
        }
        <D.19675>:
        i = i + 1;
        <D.19677>:
        D.22535 = ifaces->len;
        i.67 = (unsigned int) i;
        if (D.22535 > i.67) goto <D.19676>; else goto <D.19678>;
        <D.19678>:
        monoeg_g_ptr_array_free (ifaces, 1);
        <D.22512>:
        D.22537 = (long unsigned int) method_count;
        D.22538 = (unsigned int) D.22537;
        D.22539 = D.22538 * 8;
        extra_interface_vtsize.68 = (unsigned int) extra_interface_vtsize;
        D.22541 = D.22539 + extra_interface_vtsize.68;
        extra_interface_vtsize = (int) D.22541;
        D.22542 = iclass->max_interface_id;
        D.22543 = (int) D.22542;
        if (D.22543 > max_interface_id) goto <D.22544>; else goto <D.22545>;
        <D.22544>:
        D.22542 = iclass->max_interface_id;
        max_interface_id = (int) D.22542;
        <D.22545>:
      }
      <D.19673>:
      j = j + 1;
      <D.19680>:
      D.22546 = remote_class->interface_count;
      j.69 = (unsigned int) j;
      if (D.22546 > j.69) goto <D.19679>; else goto <D.19681>;
      <D.19681>:
      imt_thunk_builder.70 = imt_thunk_builder;
      if (imt_thunk_builder.70 != 0B) goto <D.22549>; else goto <D.22550>;
      <D.22549>:
      D.22551 = mono_stats.imt_number_of_tables;
      D.22552 = D.22551 + 1;
      mono_stats.imt_number_of_tables = D.22552;
      D.22553 = mono_stats.imt_tables_size;
      D.22554 = D.22553 + 152;
      mono_stats.imt_tables_size = D.22554;
      D.22555 = class->vtable_size;
      D.22556 = (long unsigned int) D.22555;
      D.22557 = D.22556 + 26;
      D.22558 = (unsigned int) D.22557;
      D.22559 = D.22558 * 8;
      vtsize = (int) D.22559;
      goto <D.22560>;
      <D.22550>:
      D.22561 = max_interface_id + 1;
      D.22562 = (long unsigned int) D.22561;
      D.22555 = class->vtable_size;
      D.22556 = (long unsigned int) D.22555;
      D.22563 = D.22562 + D.22556;
      D.22564 = D.22563 + 7;
      D.22565 = (unsigned int) D.22564;
      D.22566 = D.22565 * 8;
      vtsize = (int) D.22566;
      <D.22560>:
      D.22567 = mono_stats.class_vtable_size;
      D.22568 = vtsize + extra_interface_vtsize;
      D.22569 = (long unsigned int) D.22568;
      D.22570 = D.22567 + D.22569;
      mono_stats.class_vtable_size = D.22570;
      D.22568 = vtsize + extra_interface_vtsize;
      D.22571 = (unsigned int) D.22568;
      interface_offsets = mono_domain_alloc0 (domain, D.22571);
      imt_thunk_builder.70 = imt_thunk_builder;
      if (imt_thunk_builder.70 != 0B) goto <D.22572>; else goto <D.22573>;
      <D.22572>:
      pvt = interface_offsets + 152;
      goto <D.22574>;
      <D.22573>:
      D.22575 = (sizetype) max_interface_id;
      D.22576 = D.22575 + 1;
      D.22577 = D.22576 * 8;
      pvt = interface_offsets + D.22577;
      <D.22574>:
      D.22555 = class->vtable_size;
      D.22556 = (long unsigned int) D.22555;
      D.22578 = D.22556 + 7;
      D.22579 = D.22578 * 8;
      memcpy (pvt, vt, D.22579);
      D.22580 = mono_defaults.transparent_proxy_class;
      pvt->klass = D.22580;
      D.22580 = mono_defaults.transparent_proxy_class;
      D.22581 = D.22580->gc_descr;
      pvt->gc_descr = D.22581;
      mono_class_setup_vtable (class);
      i = 0;
      goto <D.19684>;
      <D.19683>:
      {
        struct MonoMethod * cm;

        D.22582 = class->vtable;
        D.22514 = (long unsigned int) i;
        D.22515 = D.22514 * 8;
        D.22583 = D.22582 + D.22515;
        cm = *D.22583;
        if (cm != 0B) goto <D.22584>; else goto <D.22585>;
        <D.22584>:
        arch_create_remoting_trampoline.71 = arch_create_remoting_trampoline;
        D.22587 = arch_create_remoting_trampoline.71 (domain, cm, target_type);
        pvt->vtable[i] = D.22587;
        goto <D.22588>;
        <D.22585>:
        pvt->vtable[i] = 0B;
        <D.22588>:
      }
      i = i + 1;
      <D.19684>:
      D.22555 = class->vtable_size;
      if (D.22555 > i) goto <D.19683>; else goto <D.19685>;
      <D.19685>:
      D.22589 = class->flags;
      D.22590 = D.22589 & 128;
      if (D.22590 != 0) goto <D.22591>; else goto <D.22592>;
      <D.22591>:
      k = class;
      goto <D.19692>;
      <D.19691>:
      {
        struct MonoMethod * m;
        void * iter;

        try
          {
            iter = 0B;
            goto <D.19689>;
            <D.19688>:
            D.22593 = m->slot;
            D.22594 = (int) D.22593;
            D.22595 = pvt->vtable[D.22594];
            if (D.22595 == 0B) goto <D.22596>; else goto <D.22597>;
            <D.22596>:
            D.22593 = m->slot;
            D.22594 = (int) D.22593;
            arch_create_remoting_trampoline.71 = arch_create_remoting_trampoline;
            D.22598 = arch_create_remoting_trampoline.71 (domain, m, target_type);
            pvt->vtable[D.22594] = D.22598;
            <D.22597>:
            <D.19689>:
            m = mono_class_get_methods (k, &iter);
            if (m != 0B) goto <D.19688>; else goto <D.19690>;
            <D.19690>:
          }
        finally
          {
            iter = {CLOBBER};
          }
      }
      k = k->parent;
      <D.19692>:
      if (k != 0B) goto <D.19691>; else goto <D.19693>;
      <D.19693>:
      <D.22592>:
      D.22599 = (short unsigned int) max_interface_id;
      pvt->max_interface_id = D.22599;
      D.22600 = max_interface_id / 8;
      bsize = D.22600 + 1;
      bsize.72 = (unsigned int) bsize;
      bitmap = mono_domain_alloc0 (domain, bsize.72);
      imt_thunk_builder.70 = imt_thunk_builder;
      if (imt_thunk_builder.70 == 0B) goto <D.22602>; else goto <D.22603>;
      <D.22602>:
      i = 0;
      goto <D.19697>;
      <D.19696>:
      {
        int interface_id;
        int slot;

        D.22604 = class->interfaces_packed;
        D.22514 = (long unsigned int) i;
        D.22515 = D.22514 * 8;
        D.22605 = D.22604 + D.22515;
        D.22606 = *D.22605;
        D.22607 = D.22606->interface_id;
        interface_id = (int) D.22607;
        D.22608 = class->interface_offsets_packed;
        D.22514 = (long unsigned int) i;
        D.22609 = D.22514 * 2;
        D.22610 = D.22608 + D.22609;
        D.22611 = *D.22610;
        slot = (int) D.22611;
        D.22487 = class->max_interface_id;
        D.22612 = (int) D.22487;
        D.22613 = D.22612 - interface_id;
        D.22614 = (long unsigned int) D.22613;
        D.22615 = D.22614 * 8;
        D.22616 = interface_offsets + D.22615;
        D.22617 = &pvt->vtable[slot];
        *D.22616 = D.22617;
      }
      i = i + 1;
      <D.19697>:
      D.22618 = class->interface_offsets_count;
      D.22619 = (int) D.22618;
      if (D.22619 > i) goto <D.19696>; else goto <D.19698>;
      <D.19698>:
      <D.22603>:
      i = 0;
      goto <D.19701>;
      <D.19700>:
      {
        int interface_id;

        D.22604 = class->interfaces_packed;
        D.22514 = (long unsigned int) i;
        D.22515 = D.22514 * 8;
        D.22605 = D.22604 + D.22515;
        D.22606 = *D.22605;
        D.22607 = D.22606->interface_id;
        interface_id = (int) D.22607;
        D.22620 = interface_id >> 3;
        D.22621 = (sizetype) D.22620;
        D.22622 = bitmap + D.22621;
        D.22620 = interface_id >> 3;
        D.22621 = (sizetype) D.22620;
        D.22622 = bitmap + D.22621;
        D.22623 = *D.22622;
        D.22624 = (signed char) D.22623;
        D.22625 = interface_id & 7;
        D.22626 = 1 << D.22625;
        D.22627 = (signed char) D.22626;
        D.22628 = D.22624 | D.22627;
        D.22629 = (unsigned char) D.22628;
        *D.22622 = D.22629;
      }
      i = i + 1;
      <D.19701>:
      D.22618 = class->interface_offsets_count;
      D.22619 = (int) D.22618;
      if (D.22619 > i) goto <D.19700>; else goto <D.19702>;
      <D.19702>:
      if (extra_interfaces != 0B) goto <D.22630>; else goto <D.22631>;
      <D.22630>:
      {
        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.19712>;
            <D.19711>:
            interf = list_item->data;
            imt_thunk_builder.70 = imt_thunk_builder;
            if (imt_thunk_builder.70 == 0B) goto <D.22632>; else goto <D.22633>;
            <D.22632>:
            D.22634 = interf->interface_id;
            D.22635 = (int) D.22634;
            D.22636 = max_interface_id - D.22635;
            D.22637 = (long unsigned int) D.22636;
            D.22638 = D.22637 * 8;
            D.22639 = interface_offsets + D.22638;
            D.22640 = &pvt->vtable[slot];
            *D.22639 = D.22640;
            <D.22633>:
            D.22634 = interf->interface_id;
            D.22641 = D.22634 >> 3;
            D.22642 = (sizetype) D.22641;
            D.22643 = bitmap + D.22642;
            D.22634 = interf->interface_id;
            D.22641 = D.22634 >> 3;
            D.22642 = (sizetype) D.22641;
            D.22643 = bitmap + D.22642;
            D.22644 = *D.22643;
            D.22645 = (signed char) D.22644;
            D.22634 = interf->interface_id;
            D.22635 = (int) D.22634;
            D.22646 = D.22635 & 7;
            D.22647 = 1 << D.22646;
            D.22648 = (signed char) D.22647;
            D.22649 = D.22645 | D.22648;
            D.22650 = (unsigned char) D.22649;
            *D.22643 = D.22650;
            iter = 0B;
            j = 0;
            goto <D.19709>;
            <D.19708>:
            j.73 = j;
            j = j.73 + 1;
            D.22652 = j.73 + slot;
            arch_create_remoting_trampoline.71 = arch_create_remoting_trampoline;
            D.22653 = arch_create_remoting_trampoline.71 (domain, cm, target_type);
            pvt->vtable[D.22652] = D.22653;
            <D.19709>:
            cm = mono_class_get_methods (interf, &iter);
            if (cm != 0B) goto <D.19708>; else goto <D.19710>;
            <D.19710>:
            D.22654 = mono_class_num_methods (interf);
            slot = D.22654 + slot;
            list_item = list_item->next;
            <D.19712>:
            if (list_item != 0B) goto <D.19711>; else goto <D.19713>;
            <D.19713>:
            imt_thunk_builder.70 = imt_thunk_builder;
            if (imt_thunk_builder.70 == 0B) goto <D.22655>; else goto <D.22656>;
            <D.22655>:
            monoeg_g_slist_free (extra_interfaces);
            <D.22656>:
          }
        finally
          {
            iter = {CLOBBER};
          }
      }
      <D.22631>:
      imt_thunk_builder.70 = imt_thunk_builder;
      if (imt_thunk_builder.70 != 0B) goto <D.22657>; else goto <D.22658>;
      <D.22657>:
      build_imt (class, pvt, domain, interface_offsets, extra_interfaces);
      if (extra_interfaces != 0B) goto <D.22659>; else goto <D.22660>;
      <D.22659>:
      monoeg_g_slist_free (extra_interfaces);
      <D.22660>:
      <D.22658>:
      pvt->interface_bitmap = bitmap;
      D.22661 = pvt;
      return D.22661;
    }
  finally
    {
      error = {CLOBBER};
    }
}


__attribute__((visibility ("hidden")))
mono_upgrade_remote_class (struct MonoDomain * domain, struct MonoObject * proxy_object, struct MonoClass * klass)
{
  union mono_mutex_t * D.22664;
  _Bool D.22667;
  long int D.22668;
  long int D.22669;
  unsigned int D.22672;
  unsigned int D.22673;
  struct MonoClass * D.22676;
  unsigned int D.22679;
  unsigned int i.74;
  struct MonoClass * D.22683;
  _Bool D.22684;
  struct MonoRemoteClass * D.22687;
  struct MonoRemoteClass * D.22688;
  struct MonoRealProxy * D.22689;
  void * D.22690;
  _Bool D.22693;
  long int D.22694;
  long int D.22695;
  struct MonoTransparentProxy * tproxy;
  struct MonoRemoteClass * remote_class;
  gboolean redo_vtable;

  mono_loader_lock ();
  {
    int ret;

    D.22664 = &domain->lock.mutex;
    ret = pthread_mutex_lock (D.22664);
    if (ret != 0) goto <D.22665>; else goto <D.22666>;
    <D.22665>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
    <D.22666>:
    D.22667 = ret != 0;
    D.22668 = (long int) D.22667;
    D.22669 = __builtin_expect (D.22668, 0);
    if (D.22669 != 0) goto <D.22670>; else goto <D.22671>;
    <D.22670>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 2661, "ret == 0");
    <D.22671>:
  }
  tproxy = proxy_object;
  remote_class = tproxy->remote_class;
  D.22672 = klass->flags;
  D.22673 = D.22672 & 32;
  if (D.22673 != 0) goto <D.22674>; else goto <D.22675>;
  <D.22674>:
  {
    int i;

    redo_vtable = 1;
    i = 0;
    goto <D.19795>;
    <D.19794>:
    D.22676 = remote_class->interfaces[i];
    if (D.22676 == klass) goto <D.22677>; else goto <D.22678>;
    <D.22677>:
    redo_vtable = 0;
    <D.22678>:
    i = i + 1;
    <D.19795>:
    D.22679 = remote_class->interface_count;
    i.74 = (unsigned int) i;
    if (D.22679 > i.74) goto <D.22681>; else goto <D.19796>;
    <D.22681>:
    if (redo_vtable != 0) goto <D.19794>; else goto <D.19796>;
    <D.19796>:
  }
  goto <D.22682>;
  <D.22675>:
  D.22683 = remote_class->proxy_class;
  D.22684 = D.22683 != klass;
  redo_vtable = (gboolean) D.22684;
  <D.22682>:
  if (redo_vtable != 0) goto <D.22685>; else goto <D.22686>;
  <D.22685>:
  D.22687 = clone_remote_class (domain, remote_class, klass);
  tproxy->remote_class = D.22687;
  D.22688 = tproxy->remote_class;
  D.22689 = tproxy->rp;
  D.22690 = mono_remote_class_vtable (domain, D.22688, D.22689);
  proxy_object->vtable = D.22690;
  <D.22686>:
  {
    int ret;

    D.22664 = &domain->lock.mutex;
    ret = pthread_mutex_unlock (D.22664);
    if (ret != 0) goto <D.22691>; else goto <D.22692>;
    <D.22691>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.22692>:
    D.22693 = ret != 0;
    D.22694 = (long int) D.22693;
    D.22695 = __builtin_expect (D.22694, 0);
    if (D.22695 != 0) goto <D.22696>; else goto <D.22697>;
    <D.22696>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 2682, "ret == 0");
    <D.22697>:
  }
  mono_loader_unlock ();
}


clone_remote_class (struct MonoDomain * domain, struct MonoRemoteClass * remote_class, struct MonoClass * extra_class)
{
  struct GHashTable * D.22698;
  struct MonoRemoteClass * D.22701;
  unsigned int D.22702;
  unsigned int D.22703;
  unsigned int D.22706;
  unsigned int D.22707;
  long unsigned int D.22708;
  long unsigned int D.22709;
  unsigned int D.22710;
  unsigned int D.22711;
  struct MonoClass * D.22712;
  struct MonoClass * D.22713;
  int j.75;
  unsigned int i.76;
  long unsigned int D.22723;
  long unsigned int D.22724;
  unsigned int D.22725;
  unsigned int D.22726;
  unsigned int D.22727;
  struct MonoClass *[0:] * D.22730;
  struct MonoClass *[0:] * D.22731;
  long unsigned int D.22732;
  long unsigned int D.22733;
  char * D.22734;
  struct MonoRemoteClass * rc;
  void * * key;
  void * * mp_key;

  key = create_remote_class_key (remote_class, extra_class);
  D.22698 = domain->proxy_vtable_hash;
  rc = monoeg_g_hash_table_lookup (D.22698, key);
  if (rc != 0B) goto <D.22699>; else goto <D.22700>;
  <D.22699>:
  monoeg_g_free (key);
  D.22701 = rc;
  return D.22701;
  <D.22700>:
  mp_key = copy_remote_class_key (domain, key);
  monoeg_g_free (key);
  key = mp_key;
  D.22702 = extra_class->flags;
  D.22703 = D.22702 & 32;
  if (D.22703 != 0) goto <D.22704>; else goto <D.22705>;
  <D.22704>:
  {
    int i;
    int j;

    D.22706 = remote_class->interface_count;
    D.22707 = D.22706 + 1;
    D.22708 = (long unsigned int) D.22707;
    D.22709 = D.22708 + 5;
    D.22710 = (unsigned int) D.22709;
    D.22711 = D.22710 * 8;
    rc = mono_domain_alloc (domain, D.22711);
    D.22712 = remote_class->proxy_class;
    rc->proxy_class = D.22712;
    D.22706 = remote_class->interface_count;
    D.22707 = D.22706 + 1;
    rc->interface_count = D.22707;
    i = 0;
    j = 0;
    goto <D.19772>;
    <D.19771>:
    D.22713 = remote_class->interfaces[i];
    if (D.22713 > extra_class) goto <D.22714>; else goto <D.22715>;
    <D.22714>:
    if (i == j) goto <D.22716>; else goto <D.22717>;
    <D.22716>:
    j.75 = j;
    j = j.75 + 1;
    rc->interfaces[j.75] = extra_class;
    <D.22717>:
    <D.22715>:
    D.22713 = remote_class->interfaces[i];
    rc->interfaces[j] = D.22713;
    i = i + 1;
    j = j + 1;
    <D.19772>:
    D.22706 = remote_class->interface_count;
    i.76 = (unsigned int) i;
    if (D.22706 > i.76) goto <D.19771>; else goto <D.19773>;
    <D.19773>:
    if (i == j) goto <D.22720>; else goto <D.22721>;
    <D.22720>:
    rc->interfaces[j] = extra_class;
    <D.22721>:
  }
  goto <D.22722>;
  <D.22705>:
  D.22706 = remote_class->interface_count;
  D.22723 = (long unsigned int) D.22706;
  D.22724 = D.22723 + 5;
  D.22725 = (unsigned int) D.22724;
  D.22726 = D.22725 * 8;
  rc = mono_domain_alloc (domain, D.22726);
  rc->proxy_class = extra_class;
  D.22706 = remote_class->interface_count;
  rc->interface_count = D.22706;
  D.22727 = rc->interface_count;
  if (D.22727 != 0) goto <D.22728>; else goto <D.22729>;
  <D.22728>:
  D.22730 = &rc->interfaces;
  D.22731 = &remote_class->interfaces;
  D.22727 = rc->interface_count;
  D.22732 = (long unsigned int) D.22727;
  D.22733 = D.22732 * 8;
  memcpy (D.22730, D.22731, D.22733);
  <D.22729>:
  <D.22722>:
  rc->default_vtable = 0B;
  rc->xdomain_vtable = 0B;
  D.22734 = remote_class->proxy_class_name;
  rc->proxy_class_name = D.22734;
  D.22698 = domain->proxy_vtable_hash;
  monoeg_g_hash_table_insert_replace (D.22698, key, rc, 0);
  D.22701 = rc;
  return D.22701;
}


mono_object_get_virtual_method (struct MonoObject * obj, struct MonoMethod * method)
{
  struct MonoVTable * D.22736;
  struct MonoClass * D.22737;
  struct MonoRemoteClass * D.22740;
  short unsigned int D.22743;
  unsigned int D.22744;
  unsigned int D.22745;
  struct MonoMethod * D.22748;
  short int D.22749;
  long unsigned int D.22752;
  long unsigned int D.22753;
  struct MonoMethod * D.22756;
  short int D.22757;
  _Bool D.22758;
  long int D.22759;
  long int D.22760;
  struct MonoClass * D.22768;
  unsigned int D.22769;
  unsigned int D.22770;
  _Bool D.22775;
  long int D.22776;
  long int D.22777;
  int D.22780;
  int D.22781;
  long unsigned int D.22782;
  long unsigned int D.22783;
  struct MonoMethod * * D.22784;
  long unsigned int D.22786;
  long unsigned int D.22787;
  struct MonoMethod * * D.22788;
  struct MonoMethodSignature * D.22794;
  short unsigned int D.22795;
  struct MonoMethodSignature * D.22796;
  short unsigned int D.22797;
  struct MonoClass * D.22804;
  long unsigned int D.22806;
  long unsigned int D.22807;
  struct MonoGenericContext * D.22811;
  _Bool D.22812;
  long int D.22813;
  long int D.22814;
  struct MonoClass * klass;
  struct MonoMethod * * vtable;
  gboolean is_proxy;
  struct MonoMethod * res;

  is_proxy = 0;
  res = 0B;
  D.22736 = obj->vtable;
  klass = D.22736->klass;
  D.22737 = mono_defaults.transparent_proxy_class;
  if (D.22737 == klass) goto <D.22738>; else goto <D.22739>;
  <D.22738>:
  D.22740 = MEM[(struct MonoTransparentProxy *)obj].remote_class;
  klass = D.22740->proxy_class;
  is_proxy = 1;
  <D.22739>:
  if (is_proxy == 0) goto <D.22741>; else goto <D.22742>;
  <D.22741>:
  D.22743 = method->flags;
  D.22744 = (unsigned int) D.22743;
  D.22745 = D.22744 & 96;
  if (D.22745 != 64) goto <D.22746>; else goto <D.22747>;
  <D.22746>:
  D.22748 = method;
  return D.22748;
  <D.22747>:
  <D.22742>:
  mono_class_setup_vtable (klass);
  vtable = klass->vtable;
  D.22749 = method->slot;
  if (D.22749 == -1) goto <D.22750>; else goto <D.22751>;
  <D.22750>:
  D.22752 = BIT_FIELD_REF <*method, 64, 256>;
  D.22753 = D.22752 & 2251799813685248;
  if (D.22753 != 0) goto <D.22754>; else goto <D.22755>;
  <D.22754>:
  D.22756 = MEM[(struct MonoMethodInflated *)method].declaring;
  D.22757 = D.22756->slot;
  D.22758 = D.22757 == -1;
  D.22759 = (long int) D.22758;
  D.22760 = __builtin_expect (D.22759, 0);
  if (D.22760 != 0) goto <D.22761>; else goto <D.22762>;
  <D.22761>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 2721, "((MonoMethodInflated*)method)->declaring->slot != -1");
  <D.22762>:
  D.22756 = MEM[(struct MonoMethodInflated *)method].declaring;
  D.22757 = D.22756->slot;
  method->slot = D.22757;
  goto <D.22763>;
  <D.22755>:
  if (is_proxy == 0) goto <D.22764>; else goto <D.22765>;
  <D.22764>:
  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "object.c", 2725);
  <D.22765>:
  <D.22763>:
  <D.22751>:
  D.22749 = method->slot;
  if (D.22749 != -1) goto <D.22766>; else goto <D.22767>;
  <D.22766>:
  D.22768 = method->klass;
  D.22769 = D.22768->flags;
  D.22770 = D.22769 & 32;
  if (D.22770 != 0) goto <D.22771>; else goto <D.22772>;
  <D.22771>:
  if (is_proxy == 0) goto <D.22773>; else goto <D.22774>;
  <D.22773>:
  {
    gboolean variance_used;
    int iface_offset;

    try
      {
        variance_used = 0;
        D.22768 = method->klass;
        iface_offset = mono_class_interface_offset_with_variance (klass, D.22768, &variance_used);
        D.22775 = iface_offset <= 0;
        D.22776 = (long int) D.22775;
        D.22777 = __builtin_expect (D.22776, 0);
        if (D.22777 != 0) goto <D.22778>; else goto <D.22779>;
        <D.22778>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 2735, "iface_offset > 0");
        <D.22779>:
        D.22749 = method->slot;
        D.22780 = (int) D.22749;
        D.22781 = D.22780 + iface_offset;
        D.22782 = (long unsigned int) D.22781;
        D.22783 = D.22782 * 8;
        D.22784 = vtable + D.22783;
        res = *D.22784;
      }
    finally
      {
        variance_used = {CLOBBER};
      }
  }
  <D.22774>:
  goto <D.22785>;
  <D.22772>:
  D.22749 = method->slot;
  D.22786 = (long unsigned int) D.22749;
  D.22787 = D.22786 * 8;
  D.22788 = vtable + D.22787;
  res = *D.22788;
  <D.22785>:
  <D.22767>:
  if (is_proxy != 0) goto <D.22789>; else goto <D.22790>;
  <D.22789>:
  if (res == 0B) goto <D.22791>; else goto <D.22793>;
  <D.22793>:
  D.22794 = mono_method_signature (res);
  D.22795 = D.22794->generic_param_count;
  if (D.22795 != 0) goto <D.22791>; else goto <D.22792>;
  <D.22791>:
  res = method;
  <D.22792>:
  D.22796 = mono_method_signature (res);
  D.22797 = D.22796->generic_param_count;
  if (D.22797 != 0) goto <D.22798>; else goto <D.22799>;
  <D.22798>:
  res = mono_marshal_get_remoting_invoke_with_check (res);
  goto <D.22800>;
  <D.22799>:
  D.22804 = mono_class_get_com_object_class ();
  if (D.22804 == klass) goto <D.22801>; else goto <D.22805>;
  <D.22805>:
  D.22806 = BIT_FIELD_REF <*klass, 64, 256>;
  D.22807 = D.22806 & 8589934592;
  if (D.22807 != 0) goto <D.22801>; else goto <D.22802>;
  <D.22801>:
  res = mono_cominterop_get_invoke (res);
  goto <D.22803>;
  <D.22802>:
  res = mono_marshal_get_remoting_invoke (res);
  <D.22803>:
  <D.22800>:
  goto <D.22808>;
  <D.22790>:
  D.22752 = BIT_FIELD_REF <*method, 64, 256>;
  D.22753 = D.22752 & 2251799813685248;
  if (D.22753 != 0) goto <D.22809>; else goto <D.22810>;
  <D.22809>:
  D.22811 = &MEM[(struct MonoMethodInflated *)method].context;
  res = mono_class_inflate_generic_method (res, D.22811);
  <D.22810>:
  <D.22808>:
  D.22812 = res == 0B;
  D.22813 = (long int) D.22812;
  D.22814 = __builtin_expect (D.22813, 0);
  if (D.22814 != 0) goto <D.22815>; else goto <D.22816>;
  <D.22815>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 2769, "res");
  <D.22816>:
  D.22748 = res;
  return D.22748;
}


mono_runtime_invoke (struct MonoMethod * method, void * obj, void * * params, struct MonoObject * * exc)
{
  int D.22818;
  char * D.22821;
  <unnamed type> D.22822;
  unsigned int D.22823;
  struct MonoObject * (*<T13ab>) (struct MonoMethod *, void *, void * *, struct MonoObject * *) default_mono_runtime_invoke.77;
  <unnamed type> D.22827;
  unsigned int D.22828;
  struct MonoObject * D.22831;
  struct MonoObject * result;

  D.22818 = mono_runtime_get_no_exec ();
  if (D.22818 != 0) goto <D.22819>; else goto <D.22820>;
  <D.22819>:
  D.22821 = mono_method_full_name (method, 1);
  monoeg_g_log (0B, 16, "Invoking method \'%s\' when running in no-exec mode.\n", D.22821);
  <D.22820>:
  D.22822 = mono_profiler_get_events ();
  D.22823 = D.22822 & 65536;
  if (D.22823 != 0) goto <D.22824>; else goto <D.22825>;
  <D.22824>:
  mono_profiler_method_start_invoke (method);
  <D.22825>:
  default_mono_runtime_invoke.77 = default_mono_runtime_invoke;
  result = default_mono_runtime_invoke.77 (method, obj, params, exc);
  D.22827 = mono_profiler_get_events ();
  D.22828 = D.22827 & 65536;
  if (D.22828 != 0) goto <D.22829>; else goto <D.22830>;
  <D.22829>:
  mono_profiler_method_end_invoke (method);
  <D.22830>:
  D.22831 = result;
  return D.22831;
}


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

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


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

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


mono_field_set_value (struct MonoObject * obj, struct MonoClassField * field, void * value)
{
  struct MonoType * D.22837;
  short unsigned int D.22838;
  int D.22839;
  int D.22840;
  int D.22843;
  sizetype D.22844;
  void * dest;

  D.22837 = field->type;
  D.22838 = D.22837->attrs;
  D.22839 = (int) D.22838;
  D.22840 = D.22839 & 16;
  if (D.22840 != 0) goto <D.22841>; else goto <D.22842>;
  <D.22841>:
  monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "object.c", 3003, "!(field->type->attrs & FIELD_ATTRIBUTE_STATIC)");
  return;
  <D.22842>:
  D.22843 = field->offset;
  D.22844 = (sizetype) D.22843;
  dest = obj + D.22844;
  D.22837 = field->type;
  set_value (D.22837, dest, value, 0);
}


set_value (struct MonoType * type, void * dest, void * value, int deref_pointer)
{
  long unsigned int D.22846;
  long unsigned int D.22847;
  unsigned char D.22850;
  guint8 iftmp.78;
  guint16 iftmp.79;
  int iftmp.80;
  gint64 iftmp.81;
  float iftmp.82;
  double iftmp.83;
  struct MonoObject * iftmp.84;
  void * iftmp.85;
  struct MonoClass * D.22885;
  long unsigned int D.22886;
  long unsigned int D.22887;
  struct MonoType * D.22889;
  unsigned char D.22890;
  long unsigned int D.22893;
  struct MonoGenericClass * D.22895;
  struct MonoClass * D.22896;
  unsigned char D.22897;
  int D.22898;
  int t;
  void handle_enum = <<< error >>>;

  D.22846 = BIT_FIELD_REF <*type, 64, 64>;
  D.22847 = D.22846 & 8589934592;
  if (D.22847 != 0) goto <D.22848>; else goto <D.22849>;
  <D.22848>:
  {
    void * * p;

    p = dest;
    *p = value;
    return;
  }
  <D.22849>:
  D.22850 = type->type;
  t = (int) D.22850;
  handle_enum:
  switch (t) <default: <D.19867>, case 2: <D.19835>, case 3: <D.19841>, case 4: <D.19836>, case 5: <D.19837>, case 6: <D.19839>, case 7: <D.19840>, case 8: <D.19843>, case 9: <D.19844>, case 10: <D.19848>, case 11: <D.19849>, case 12: <D.19851>, case 13: <D.19853>, case 14: <D.19855>, case 15: <D.19861>, case 17: <D.19863>, case 18: <D.19857>, case 20: <D.19859>, case 21: <D.19866>, case 24: <D.19846>, case 25: <D.19847>, case 27: <D.19860>, case 28: <D.19858>, case 29: <D.19856>>
  <D.19835>:
  <D.19836>:
  <D.19837>:
  {
    guint8 * p;

    p = dest;
    if (value != 0B) goto <D.22852>; else goto <D.22853>;
    <D.22852>:
    iftmp.78 = MEM[(guint8 *)value];
    goto <D.22854>;
    <D.22853>:
    iftmp.78 = 0;
    <D.22854>:
    *p = iftmp.78;
    return;
  }
  <D.19839>:
  <D.19840>:
  <D.19841>:
  {
    guint16 * p;

    p = dest;
    if (value != 0B) goto <D.22856>; else goto <D.22857>;
    <D.22856>:
    iftmp.79 = MEM[(guint16 *)value];
    goto <D.22858>;
    <D.22857>:
    iftmp.79 = 0;
    <D.22858>:
    *p = iftmp.79;
    return;
  }
  <D.19843>:
  <D.19844>:
  {
    gint32 * p;

    p = dest;
    if (value != 0B) goto <D.22860>; else goto <D.22861>;
    <D.22860>:
    iftmp.80 = MEM[(gint32 *)value];
    goto <D.22862>;
    <D.22861>:
    iftmp.80 = 0;
    <D.22862>:
    *p = iftmp.80;
    return;
  }
  <D.19846>:
  <D.19847>:
  <D.19848>:
  <D.19849>:
  {
    gint64 * p;

    p = dest;
    if (value != 0B) goto <D.22864>; else goto <D.22865>;
    <D.22864>:
    iftmp.81 = MEM[(gint64 *)value];
    goto <D.22866>;
    <D.22865>:
    iftmp.81 = 0;
    <D.22866>:
    *p = iftmp.81;
    return;
  }
  <D.19851>:
  {
    float * p;

    p = dest;
    if (value != 0B) goto <D.22868>; else goto <D.22869>;
    <D.22868>:
    iftmp.82 = MEM[(float *)value];
    goto <D.22870>;
    <D.22869>:
    iftmp.82 = 0.0;
    <D.22870>:
    *p = iftmp.82;
    return;
  }
  <D.19853>:
  {
    double * p;

    p = dest;
    if (value != 0B) goto <D.22872>; else goto <D.22873>;
    <D.22872>:
    iftmp.83 = MEM[(double *)value];
    goto <D.22874>;
    <D.22873>:
    iftmp.83 = 0.0;
    <D.22874>:
    *p = iftmp.83;
    return;
  }
  <D.19855>:
  <D.19856>:
  <D.19857>:
  <D.19858>:
  <D.19859>:
  if (deref_pointer != 0) goto <D.22876>; else goto <D.22877>;
  <D.22876>:
  iftmp.84 = MEM[(void * *)value];
  goto <D.22878>;
  <D.22877>:
  iftmp.84 = value;
  <D.22878>:
  mono_gc_wbarrier_generic_store (dest, iftmp.84);
  return;
  <D.19860>:
  <D.19861>:
  {
    void * * p;

    p = dest;
    if (deref_pointer != 0) goto <D.22880>; else goto <D.22881>;
    <D.22880>:
    iftmp.85 = MEM[(void * *)value];
    goto <D.22882>;
    <D.22881>:
    iftmp.85 = value;
    <D.22882>:
    *p = iftmp.85;
    return;
  }
  <D.19863>:
  D.22850 = type->type;
  if (D.22850 == 17) goto <D.22884>; else goto <D.22883>;
  <D.22884>:
  D.22885 = type->data.klass;
  D.22886 = BIT_FIELD_REF <*D.22885, 64, 256>;
  D.22887 = D.22886 & 576460752303423488;
  if (D.22887 != 0) goto <D.22888>; else goto <D.22883>;
  <D.22888>:
  D.22885 = type->data.klass;
  D.22889 = mono_class_enum_basetype (D.22885);
  D.22890 = D.22889->type;
  t = (int) D.22890;
  goto handle_enum;
  <D.22883>:
  {
    struct MonoClass * class;
    int size;

    class = mono_class_from_mono_type (type);
    size = mono_class_value_size (class, 0B);
    if (value == 0B) goto <D.22891>; else goto <D.22892>;
    <D.22891>:
    D.22893 = (long unsigned int) size;
    mono_gc_bzero_atomic (dest, D.22893);
    goto <D.22894>;
    <D.22892>:
    mono_gc_wbarrier_value_copy (dest, value, 1, class);
    <D.22894>:
  }
  return;
  <D.19866>:
  D.22895 = type->data.generic_class;
  D.22896 = D.22895->container_class;
  D.22897 = D.22896->byval_arg.type;
  t = (int) D.22897;
  goto handle_enum;
  <D.19867>:
  D.22850 = type->type;
  D.22898 = (int) D.22850;
  monoeg_g_log (0B, 4, "got type %x", D.22898);
  <D.19868>:
  goto <D.19868>;
}


mono_field_static_set_value (struct MonoVTable * vt, struct MonoClassField * field, void * value)
{
  struct MonoType * D.22900;
  short unsigned int D.22901;
  int D.22902;
  int D.22903;
  int D.22906;
  int D.22909;
  struct MonoDomain * D.22912;
  union mono_mutex_t * D.22913;
  _Bool D.22916;
  long int D.22917;
  long int D.22918;
  struct GHashTable * D.22921;
  _Bool D.22924;
  long int D.22925;
  long int D.22926;
  long int addr.86;
  unsigned int D.22930;
  void * D.22932;
  sizetype D.22933;
  void * dest;

  D.22900 = field->type;
  D.22901 = D.22900->attrs;
  D.22902 = (int) D.22901;
  D.22903 = D.22902 & 16;
  if (D.22903 == 0) goto <D.22904>; else goto <D.22905>;
  <D.22904>:
  monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "object.c", 3024, "field->type->attrs & FIELD_ATTRIBUTE_STATIC");
  return;
  <D.22905>:
  D.22900 = field->type;
  D.22901 = D.22900->attrs;
  D.22902 = (int) D.22901;
  D.22906 = D.22902 & 64;
  if (D.22906 != 0) goto <D.22907>; else goto <D.22908>;
  <D.22907>:
  monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "object.c", 3026, "!(field->type->attrs & FIELD_ATTRIBUTE_LITERAL)");
  return;
  <D.22908>:
  D.22909 = field->offset;
  if (D.22909 == -1) goto <D.22910>; else goto <D.22911>;
  <D.22910>:
  {
    void * addr;

    {
      int ret;

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

      D.22912 = vt->domain;
      D.22913 = &D.22912->lock.mutex;
      ret = pthread_mutex_unlock (D.22913);
      if (ret != 0) goto <D.22922>; else goto <D.22923>;
      <D.22922>:
      monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
      <D.22923>:
      D.22924 = ret != 0;
      D.22925 = (long int) D.22924;
      D.22926 = __builtin_expect (D.22925, 0);
      if (D.22926 != 0) goto <D.22927>; else goto <D.22928>;
      <D.22927>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 3034, "ret == 0");
      <D.22928>:
    }
    addr.86 = (long int) addr;
    D.22930 = (unsigned int) addr.86;
    dest = mono_get_special_static_data (D.22930);
  }
  goto <D.22931>;
  <D.22911>:
  D.22932 = mono_vtable_get_static_field_data (vt);
  D.22909 = field->offset;
  D.22933 = (sizetype) D.22909;
  dest = D.22932 + D.22933;
  <D.22931>:
  D.22900 = field->type;
  set_value (D.22900, dest, value, 0);
}


mono_vtable_get_static_field_data (struct MonoVTable * vt)
{
  long unsigned int D.22935;
  long unsigned int D.22936;
  void * D.22939;
  struct MonoClass * D.22940;
  int D.22941;

  D.22935 = BIT_FIELD_REF <*vt, 64, 320>;
  D.22936 = D.22935 & 68719476736;
  if (D.22936 == 0) goto <D.22937>; else goto <D.22938>;
  <D.22937>:
  D.22939 = 0B;
  return D.22939;
  <D.22938>:
  D.22940 = vt->klass;
  D.22941 = D.22940->vtable_size;
  D.22939 = vt->vtable[D.22941];
  return D.22939;
}


mono_field_get_value (struct MonoObject * obj, struct MonoClassField * field, void * value)
{
  _Bool D.22943;
  long int D.22944;
  long int D.22945;
  struct MonoType * D.22948;
  short unsigned int D.22949;
  int D.22950;
  int D.22951;
  int D.22954;
  sizetype D.22955;
  void * src;

  D.22943 = obj == 0B;
  D.22944 = (long int) D.22943;
  D.22945 = __builtin_expect (D.22944, 0);
  if (D.22945 != 0) goto <D.22946>; else goto <D.22947>;
  <D.22946>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 3103, "obj");
  <D.22947>:
  D.22948 = field->type;
  D.22949 = D.22948->attrs;
  D.22950 = (int) D.22949;
  D.22951 = D.22950 & 16;
  if (D.22951 != 0) goto <D.22952>; else goto <D.22953>;
  <D.22952>:
  monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "object.c", 3105, "!(field->type->attrs & FIELD_ATTRIBUTE_STATIC)");
  return;
  <D.22953>:
  D.22954 = field->offset;
  D.22955 = (sizetype) D.22954;
  src = obj + D.22955;
  D.22948 = field->type;
  set_value (D.22948, value, src, 1);
}


mono_field_get_value_object (struct MonoDomain * domain, struct MonoClassField * field, struct MonoObject * obj)
{
  int D.22957;
  unsigned char D.22960;
  int D.22961;
  <unnamed-unsigned:1> D.22962;
  int D.22963;
  _Bool D.22964;
  struct MonoObject * D.22965;
  short unsigned int D.22966;
  int D.22967;
  int D.22968;
  int D.22971;
  struct MonoClass * D.22976;
  long unsigned int D.22977;
  long unsigned int D.22978;
  _Bool D.22982;
  long int D.22983;
  long int D.22984;
  struct MonoMethod * m.87;
  struct MonoClass * ptr_klass.90;
  struct MonoClass * tmp_klass.88;
  struct MonoImage * D.23005;
  struct MonoClass * tmp_klass.89;
  _Bool D.23007;
  long int D.23008;
  long int D.23009;
  struct MonoMethod * m.91;
  _Bool D.23013;
  long int D.23014;
  long int D.23015;
  void * * ptr.92;
  void * D.23025;
  struct MonoDomain * D.23026;
  struct MonoReflectionType * D.23027;
  int D.23028;
  guint8 * D.23031;
  struct MonoObject * o.93;
  struct MonoObject * o.94;
  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.22957 = mono_error_ok (&error);
      if (D.22957 == 0) goto <D.22958>; else goto <D.22959>;
      <D.22958>:
      mono_error_raise_exception (&error);
      <D.22959>:
      D.22960 = type->type;
      D.22961 = (int) D.22960;
      switch (D.22961) <default: <D.19940>, case 2: <D.19925>, case 3: <D.19928>, case 4: <D.19924>, case 5: <D.19923>, case 6: <D.19927>, case 7: <D.19926>, case 8: <D.19932>, case 9: <D.19931>, case 10: <D.19935>, case 11: <D.19934>, case 12: <D.19933>, case 13: <D.19936>, case 14: <D.19917>, case 15: <D.19939>, case 17: <D.19937>, case 18: <D.19919>, case 20: <D.19920>, case 21: <D.19938>, case 24: <D.19930>, case 25: <D.19929>, case 28: <D.19918>, case 29: <D.19921>>
      <D.19917>:
      <D.19918>:
      <D.19919>:
      <D.19920>:
      <D.19921>:
      is_ref = 1;
      goto <D.19922>;
      <D.19923>:
      <D.19924>:
      <D.19925>:
      <D.19926>:
      <D.19927>:
      <D.19928>:
      <D.19929>:
      <D.19930>:
      <D.19931>:
      <D.19932>:
      <D.19933>:
      <D.19934>:
      <D.19935>:
      <D.19936>:
      <D.19937>:
      D.22962 = type->byref;
      is_ref = (gboolean) D.22962;
      goto <D.19922>;
      <D.19938>:
      D.22963 = mono_type_generic_inst_is_valuetype (type);
      D.22964 = D.22963 == 0;
      is_ref = (gboolean) D.22964;
      goto <D.19922>;
      <D.19939>:
      is_ptr = 1;
      goto <D.19922>;
      <D.19940>:
      D.22960 = type->type;
      D.22961 = (int) D.22960;
      monoeg_g_log (0B, 4, "type 0x%x not handled in mono_field_get_value_object", D.22961);
      <D.19941>:
      goto <D.19941>;
      D.22965 = 0B;
      return D.22965;
      <D.19922>:
      D.22966 = type->attrs;
      D.22967 = (int) D.22966;
      D.22968 = D.22967 & 64;
      if (D.22968 != 0) goto <D.22969>; else goto <D.22970>;
      <D.22969>:
      is_literal = 1;
      <D.22970>:
      D.22966 = type->attrs;
      D.22967 = (int) D.22966;
      D.22971 = D.22967 & 16;
      if (D.22971 != 0) goto <D.22972>; else goto <D.22973>;
      <D.22972>:
      is_static = 1;
      if (is_literal == 0) goto <D.22974>; else goto <D.22975>;
      <D.22974>:
      D.22976 = field->parent;
      vtable = mono_class_vtable_full (domain, D.22976, 1);
      D.22977 = BIT_FIELD_REF <*vtable, 64, 320>;
      D.22978 = D.22977 & 274877906944;
      if (D.22978 == 0) goto <D.22979>; else goto <D.22980>;
      <D.22979>:
      mono_runtime_class_init (vtable);
      <D.22980>:
      <D.22975>:
      goto <D.22981>;
      <D.22973>:
      D.22982 = obj == 0B;
      D.22983 = (long int) D.22982;
      D.22984 = __builtin_expect (D.22983, 0);
      if (D.22984 != 0) goto <D.22985>; else goto <D.22986>;
      <D.22985>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 3187, "obj");
      <D.22986>:
      <D.22981>:
      if (is_ref != 0) goto <D.22987>; else goto <D.22988>;
      <D.22987>:
      if (is_literal != 0) goto <D.22989>; else goto <D.22990>;
      <D.22989>:
      get_default_field_value (domain, field, &o);
      goto <D.22991>;
      <D.22990>:
      if (is_static != 0) goto <D.22992>; else goto <D.22993>;
      <D.22992>:
      mono_field_static_get_value (vtable, field, &o);
      goto <D.22994>;
      <D.22993>:
      mono_field_get_value (obj, field, &o);
      <D.22994>:
      <D.22991>:
      D.22965 = o;
      return D.22965;
      <D.22988>:
      if (is_ptr != 0) goto <D.22995>; else goto <D.22996>;
      <D.22995>:
      {
        static struct MonoMethod * m;
        void * args[2];
        void * * ptr;
        void * v;

        try
          {
            m.87 = m;
            if (m.87 == 0B) goto <D.22998>; else goto <D.22999>;
            <D.22998>:
            {
              struct MonoClass * ptr_klass;

              {
                static struct MonoClass * tmp_klass;

                {
                  tmp_klass.88 = tmp_klass;
                  if (tmp_klass.88 == 0B) goto <D.23001>; else goto <D.23002>;
                  <D.23001>:
                  if (0 != 0) goto <D.23003>; else goto <D.23004>;
                  <D.23003>:
                  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 3208, "mono_defaults.corlib == mono_defaults.corlib");
                  <D.23004>:
                  D.23005 = mono_defaults.corlib;
                  tmp_klass.89 = mono_class_from_name (D.23005, "System.Reflection", "Pointer");
                  tmp_klass = tmp_klass.89;
                  tmp_klass.88 = tmp_klass;
                  D.23007 = tmp_klass.88 == 0B;
                  D.23008 = (long int) D.23007;
                  D.23009 = __builtin_expect (D.23008, 0);
                  if (D.23009 != 0) goto <D.23010>; else goto <D.23011>;
                  <D.23010>:
                  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 3208, "tmp_klass");
                  <D.23011>:
                  <D.23002>:
                }
                ptr_klass.90 = tmp_klass;
              }
              ptr_klass = ptr_klass.90;
              m.91 = mono_class_get_method_from_name_flags (ptr_klass, "Box", 2, 16);
              m = m.91;
              m.87 = m;
              D.23013 = m.87 == 0B;
              D.23014 = (long int) D.23013;
              D.23015 = __builtin_expect (D.23014, 0);
              if (D.23015 != 0) goto <D.23016>; else goto <D.23017>;
              <D.23016>:
              monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 3210, "m");
              <D.23017>:
            }
            <D.22999>:
            v = &ptr;
            if (is_literal != 0) goto <D.23018>; else goto <D.23019>;
            <D.23018>:
            get_default_field_value (domain, field, v);
            goto <D.23020>;
            <D.23019>:
            if (is_static != 0) goto <D.23021>; else goto <D.23022>;
            <D.23021>:
            mono_field_static_get_value (vtable, field, v);
            goto <D.23023>;
            <D.23022>:
            mono_field_get_value (obj, field, v);
            <D.23023>:
            <D.23020>:
            ptr.92 = ptr;
            D.23025 = *ptr.92;
            args[0] = D.23025;
            D.23026 = mono_domain_get ();
            D.23027 = mono_type_get_object (D.23026, type);
            args[1] = D.23027;
            m.87 = m;
            D.22965 = mono_runtime_invoke (m.87, 0B, &args, 0B);
            return D.22965;
          }
        finally
          {
            args = {CLOBBER};
            ptr = {CLOBBER};
          }
      }
      <D.22996>:
      klass = mono_class_from_mono_type (type);
      D.23028 = mono_class_is_nullable (klass);
      if (D.23028 != 0) goto <D.23029>; else goto <D.23030>;
      <D.23029>:
      D.23031 = mono_field_get_addr (obj, vtable, field);
      D.22965 = mono_nullable_box (D.23031, klass);
      return D.22965;
      <D.23030>:
      o.93 = mono_object_new (domain, klass);
      o = o.93;
      o.94 = o;
      v = o.94 + 16;
      if (is_literal != 0) goto <D.23034>; else goto <D.23035>;
      <D.23034>:
      get_default_field_value (domain, field, v);
      goto <D.23036>;
      <D.23035>:
      if (is_static != 0) goto <D.23037>; else goto <D.23038>;
      <D.23037>:
      mono_field_static_get_value (vtable, field, v);
      goto <D.23039>;
      <D.23038>:
      mono_field_get_value (obj, field, v);
      <D.23039>:
      <D.23036>:
      D.22965 = o;
      return D.22965;
    }
  finally
    {
      o = {CLOBBER};
      error = {CLOBBER};
    }
}


mono_field_get_addr (struct MonoObject * obj, struct MonoVTable * vt, struct MonoClassField * field)
{
  struct MonoType * D.23043;
  short unsigned int D.23044;
  int D.23045;
  int D.23046;
  int D.23049;
  struct MonoDomain * D.23052;
  union mono_mutex_t * D.23053;
  _Bool D.23056;
  long int D.23057;
  long int D.23058;
  struct GHashTable * D.23061;
  _Bool D.23064;
  long int D.23065;
  long int D.23066;
  long int addr.95;
  unsigned int D.23070;
  void * D.23072;
  sizetype D.23073;
  guint8 * D.23075;
  guint8 * src;

  D.23043 = field->type;
  D.23044 = D.23043->attrs;
  D.23045 = (int) D.23044;
  D.23046 = D.23045 & 16;
  if (D.23046 != 0) goto <D.23047>; else goto <D.23048>;
  <D.23047>:
  D.23049 = field->offset;
  if (D.23049 == -1) goto <D.23050>; else goto <D.23051>;
  <D.23050>:
  {
    void * addr;

    {
      int ret;

      D.23052 = vt->domain;
      D.23053 = &D.23052->lock.mutex;
      ret = pthread_mutex_lock (D.23053);
      if (ret != 0) goto <D.23054>; else goto <D.23055>;
      <D.23054>:
      monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
      <D.23055>:
      D.23056 = ret != 0;
      D.23057 = (long int) D.23056;
      D.23058 = __builtin_expect (D.23057, 0);
      if (D.23058 != 0) goto <D.23059>; else goto <D.23060>;
      <D.23059>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 3067, "ret == 0");
      <D.23060>:
    }
    D.23052 = vt->domain;
    D.23061 = D.23052->special_static_fields;
    addr = monoeg_g_hash_table_lookup (D.23061, field);
    {
      int ret;

      D.23052 = vt->domain;
      D.23053 = &D.23052->lock.mutex;
      ret = pthread_mutex_unlock (D.23053);
      if (ret != 0) goto <D.23062>; else goto <D.23063>;
      <D.23062>:
      monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
      <D.23063>:
      D.23064 = ret != 0;
      D.23065 = (long int) D.23064;
      D.23066 = __builtin_expect (D.23065, 0);
      if (D.23066 != 0) goto <D.23067>; else goto <D.23068>;
      <D.23067>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 3069, "ret == 0");
      <D.23068>:
    }
    addr.95 = (long int) addr;
    D.23070 = (unsigned int) addr.95;
    src = mono_get_special_static_data (D.23070);
  }
  goto <D.23071>;
  <D.23051>:
  D.23072 = mono_vtable_get_static_field_data (vt);
  D.23049 = field->offset;
  D.23073 = (sizetype) D.23049;
  src = D.23072 + D.23073;
  <D.23071>:
  goto <D.23074>;
  <D.23048>:
  D.23049 = field->offset;
  D.23073 = (sizetype) D.23049;
  src = obj + D.23073;
  <D.23074>:
  D.23075 = src;
  return D.23075;
}


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

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


__attribute__((visibility ("hidden")))
mono_get_constant_value_from_blob (struct MonoDomain * domain, MonoTypeEnum type, const char * blob, void * value)
{
  const char * p.97;
  char D.23079;
  short unsigned int D.23080;
  short unsigned int D.23081;
  signed short D.23082;
  int D.23083;
  int D.23084;
  signed short D.23085;
  signed short D.23086;
  short unsigned int D.23087;
  unsigned int D.23088;
  unsigned int D.23089;
  unsigned int D.23090;
  unsigned int D.23091;
  unsigned int D.23092;
  unsigned int D.23093;
  unsigned int D.23094;
  unsigned int D.23095;
  unsigned int D.23096;
  unsigned int D.23097;
  long unsigned int D.23098;
  unsigned int D.23099;
  unsigned int D.23100;
  unsigned int D.23101;
  unsigned int D.23102;
  unsigned int D.23103;
  unsigned int D.23104;
  unsigned int D.23105;
  unsigned int D.23106;
  unsigned int D.23107;
  unsigned int D.23108;
  long unsigned int D.23109;
  long unsigned int D.23110;
  long unsigned int D.23111;
  unsigned int D.23112;
  unsigned int D.23113;
  unsigned int D.23114;
  unsigned int D.23115;
  unsigned int D.23116;
  unsigned int D.23117;
  unsigned int D.23118;
  unsigned int D.23119;
  unsigned int D.23120;
  unsigned int D.23121;
  long unsigned int D.23122;
  long unsigned int D.23123;
  float D.23124;
  double D.23125;
  struct MonoString * D.23126;
  int D.23127;
  int retval;
  const char * p;

  try
    {
      retval = 0;
      p = blob;
      p.97 = p;
      mono_metadata_decode_blob_size (p.97, &p);
      switch (type) <default: <D.19974>, case 2: <D.19957>, case 3: <D.19961>, case 4: <D.19959>, case 5: <D.19958>, case 6: <D.19963>, case 7: <D.19962>, case 8: <D.19965>, case 9: <D.19964>, case 10: <D.19967>, case 11: <D.19966>, case 12: <D.19968>, case 13: <D.19970>, case 14: <D.19972>, case 18: <D.19973>>
      <D.19957>:
      <D.19958>:
      <D.19959>:
      p.97 = p;
      D.23079 = *p.97;
      MEM[(guint8 *)value] = D.23079;
      goto <D.19960>;
      <D.19961>:
      <D.19962>:
      <D.19963>:
      p.97 = p;
      D.23080 = MEM[(const guint16 *)p.97];
      D.23081 = D.23080 >> 8;
      D.23082 = (signed short) D.23081;
      p.97 = p;
      D.23080 = MEM[(const guint16 *)p.97];
      D.23083 = (int) D.23080;
      D.23084 = D.23083 << 8;
      D.23085 = (signed short) D.23084;
      D.23086 = D.23082 | D.23085;
      D.23087 = (short unsigned int) D.23086;
      MEM[(guint16 *)value] = D.23087;
      goto <D.19960>;
      <D.19964>:
      <D.19965>:
      p.97 = p;
      D.23088 = MEM[(const guint32 *)p.97];
      D.23089 = D.23088 << 24;
      p.97 = p;
      D.23088 = MEM[(const guint32 *)p.97];
      D.23090 = D.23088 >> 8;
      D.23091 = D.23090 & 65280;
      D.23092 = D.23089 | D.23091;
      p.97 = p;
      D.23088 = MEM[(const guint32 *)p.97];
      D.23093 = D.23088 << 8;
      D.23094 = D.23093 & 16711680;
      D.23095 = D.23092 | D.23094;
      p.97 = p;
      D.23088 = MEM[(const guint32 *)p.97];
      D.23096 = D.23088 >> 24;
      D.23097 = D.23095 | D.23096;
      MEM[(guint32 *)value] = D.23097;
      goto <D.19960>;
      <D.19966>:
      <D.19967>:
      p.97 = p;
      D.23098 = MEM[(const guint64 *)p.97];
      D.23099 = (unsigned int) D.23098;
      D.23100 = D.23099 << 24;
      p.97 = p;
      D.23098 = MEM[(const guint64 *)p.97];
      D.23099 = (unsigned int) D.23098;
      D.23101 = D.23099 >> 8;
      D.23102 = D.23101 & 65280;
      D.23103 = D.23100 | D.23102;
      p.97 = p;
      D.23098 = MEM[(const guint64 *)p.97];
      D.23099 = (unsigned int) D.23098;
      D.23104 = D.23099 << 8;
      D.23105 = D.23104 & 16711680;
      D.23106 = D.23103 | D.23105;
      p.97 = p;
      D.23098 = MEM[(const guint64 *)p.97];
      D.23099 = (unsigned int) D.23098;
      D.23107 = D.23099 >> 24;
      D.23108 = D.23106 | D.23107;
      D.23109 = (long unsigned int) D.23108;
      D.23110 = D.23109 << 32;
      p.97 = p;
      D.23098 = MEM[(const guint64 *)p.97];
      D.23111 = D.23098 >> 32;
      D.23112 = (unsigned int) D.23111;
      D.23113 = D.23112 << 24;
      p.97 = p;
      D.23098 = MEM[(const guint64 *)p.97];
      D.23111 = D.23098 >> 32;
      D.23112 = (unsigned int) D.23111;
      D.23114 = D.23112 >> 8;
      D.23115 = D.23114 & 65280;
      D.23116 = D.23113 | D.23115;
      p.97 = p;
      D.23098 = MEM[(const guint64 *)p.97];
      D.23111 = D.23098 >> 32;
      D.23112 = (unsigned int) D.23111;
      D.23117 = D.23112 << 8;
      D.23118 = D.23117 & 16711680;
      D.23119 = D.23116 | D.23118;
      p.97 = p;
      D.23098 = MEM[(const guint64 *)p.97];
      D.23111 = D.23098 >> 32;
      D.23112 = (unsigned int) D.23111;
      D.23120 = D.23112 >> 24;
      D.23121 = D.23119 | D.23120;
      D.23122 = (long unsigned int) D.23121;
      D.23123 = D.23110 | D.23122;
      MEM[(guint64 *)value] = D.23123;
      goto <D.19960>;
      <D.19968>:
      {
        union mono_rfloat mf;

        try
          {
            p.97 = p;
            D.23088 = MEM[(const guint32 *)p.97];
            D.23089 = D.23088 << 24;
            p.97 = p;
            D.23088 = MEM[(const guint32 *)p.97];
            D.23090 = D.23088 >> 8;
            D.23091 = D.23090 & 65280;
            D.23092 = D.23089 | D.23091;
            p.97 = p;
            D.23088 = MEM[(const guint32 *)p.97];
            D.23093 = D.23088 << 8;
            D.23094 = D.23093 & 16711680;
            D.23095 = D.23092 | D.23094;
            p.97 = p;
            D.23088 = MEM[(const guint32 *)p.97];
            D.23096 = D.23088 >> 24;
            D.23097 = D.23095 | D.23096;
            mf.ival = D.23097;
            D.23124 = mf.fval;
            MEM[(float *)value] = D.23124;
          }
        finally
          {
            mf = {CLOBBER};
          }
      }
      goto <D.19960>;
      <D.19970>:
      {
        union mono_rdouble mf;

        try
          {
            p.97 = p;
            D.23098 = MEM[(const guint64 *)p.97];
            D.23099 = (unsigned int) D.23098;
            D.23100 = D.23099 << 24;
            p.97 = p;
            D.23098 = MEM[(const guint64 *)p.97];
            D.23099 = (unsigned int) D.23098;
            D.23101 = D.23099 >> 8;
            D.23102 = D.23101 & 65280;
            D.23103 = D.23100 | D.23102;
            p.97 = p;
            D.23098 = MEM[(const guint64 *)p.97];
            D.23099 = (unsigned int) D.23098;
            D.23104 = D.23099 << 8;
            D.23105 = D.23104 & 16711680;
            D.23106 = D.23103 | D.23105;
            p.97 = p;
            D.23098 = MEM[(const guint64 *)p.97];
            D.23099 = (unsigned int) D.23098;
            D.23107 = D.23099 >> 24;
            D.23108 = D.23106 | D.23107;
            D.23109 = (long unsigned int) D.23108;
            D.23110 = D.23109 << 32;
            p.97 = p;
            D.23098 = MEM[(const guint64 *)p.97];
            D.23111 = D.23098 >> 32;
            D.23112 = (unsigned int) D.23111;
            D.23113 = D.23112 << 24;
            p.97 = p;
            D.23098 = MEM[(const guint64 *)p.97];
            D.23111 = D.23098 >> 32;
            D.23112 = (unsigned int) D.23111;
            D.23114 = D.23112 >> 8;
            D.23115 = D.23114 & 65280;
            D.23116 = D.23113 | D.23115;
            p.97 = p;
            D.23098 = MEM[(const guint64 *)p.97];
            D.23111 = D.23098 >> 32;
            D.23112 = (unsigned int) D.23111;
            D.23117 = D.23112 << 8;
            D.23118 = D.23117 & 16711680;
            D.23119 = D.23116 | D.23118;
            p.97 = p;
            D.23098 = MEM[(const guint64 *)p.97];
            D.23111 = D.23098 >> 32;
            D.23112 = (unsigned int) D.23111;
            D.23120 = D.23112 >> 24;
            D.23121 = D.23119 | D.23120;
            D.23122 = (long unsigned int) D.23121;
            D.23123 = D.23110 | D.23122;
            mf.ival = D.23123;
            D.23125 = mf.fval;
            MEM[(double *)value] = D.23125;
          }
        finally
          {
            mf = {CLOBBER};
          }
      }
      goto <D.19960>;
      <D.19972>:
      D.23126 = mono_ldstr_metadata_sig (domain, blob);
      MEM[(void * *)value] = D.23126;
      goto <D.19960>;
      <D.19973>:
      MEM[(void * *)value] = 0B;
      goto <D.19960>;
      <D.19974>:
      retval = -1;
      monoeg_g_log (0B, 16, "type 0x%02x should not be in constant table", type);
      <D.19960>:
      D.23127 = retval;
      return D.23127;
    }
  finally
    {
      p = {CLOBBER};
    }
}


mono_ldstr_metadata_sig (struct MonoDomain * domain, const char * sig)
{
  const char * str.98;
  unsigned int D.23131;
  int D.23132;
  short unsigned int D.23133;
  short unsigned int D.23134;
  signed short D.23135;
  int D.23136;
  int D.23137;
  signed short D.23138;
  signed short D.23139;
  short unsigned int D.23140;
  long unsigned int D.23141;
  _Bool D.23144;
  long int D.23145;
  long int D.23146;
  struct MonoGHashTable * D.23149;
  _Bool D.23154;
  long int D.23155;
  long int D.23156;
  struct MonoString * D.23159;
  _Bool D.23164;
  long int D.23165;
  long int D.23166;
  const char * str;
  struct MonoString * o;
  struct MonoString * interned;
  size_t len2;

  try
    {
      str = sig;
      str.98 = str;
      D.23131 = mono_metadata_decode_blob_size (str.98, &str);
      len2 = (size_t) D.23131;
      len2 = len2 >> 1;
      str.98 = str;
      D.23132 = (int) len2;
      o = mono_string_new_utf16 (domain, str.98, D.23132);
      {
        int i;
        guint16 * p2;

        p2 = mono_string_chars (o);
        i = 0;
        goto <D.20512>;
        <D.20511>:
        D.23133 = *p2;
        D.23134 = D.23133 >> 8;
        D.23135 = (signed short) D.23134;
        D.23133 = *p2;
        D.23136 = (int) D.23133;
        D.23137 = D.23136 << 8;
        D.23138 = (signed short) D.23137;
        D.23139 = D.23135 | D.23138;
        D.23140 = (short unsigned int) D.23139;
        *p2 = D.23140;
        p2 = p2 + 2;
        i = i + 1;
        <D.20512>:
        D.23141 = (long unsigned int) i;
        if (D.23141 < len2) goto <D.20511>; else goto <D.20513>;
        <D.20513>:
      }
      {
        int ret;

        ret = pthread_mutex_lock (&ldstr_section.mutex);
        if (ret != 0) goto <D.23142>; else goto <D.23143>;
        <D.23142>:
        monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
        <D.23143>:
        D.23144 = ret != 0;
        D.23145 = (long int) D.23144;
        D.23146 = __builtin_expect (D.23145, 0);
        if (D.23146 != 0) goto <D.23147>; else goto <D.23148>;
        <D.23147>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 5487, "ret == 0");
        <D.23148>:
      }
      D.23149 = domain->ldstr_table;
      interned = mono_g_hash_table_lookup (D.23149, o);
      if (interned != 0B) goto <D.23150>; else goto <D.23151>;
      <D.23150>:
      {
        int ret;

        ret = pthread_mutex_unlock (&ldstr_section.mutex);
        if (ret != 0) goto <D.23152>; else goto <D.23153>;
        <D.23152>:
        monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
        <D.23153>:
        D.23154 = ret != 0;
        D.23155 = (long int) D.23154;
        D.23156 = __builtin_expect (D.23155, 0);
        if (D.23156 != 0) goto <D.23157>; else goto <D.23158>;
        <D.23157>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 5489, "ret == 0");
        <D.23158>:
      }
      D.23159 = interned;
      return D.23159;
      <D.23151>:
      o = mono_string_get_pinned (o);
      if (o != 0B) goto <D.23160>; else goto <D.23161>;
      <D.23160>:
      D.23149 = domain->ldstr_table;
      mono_g_hash_table_insert (D.23149, o, o);
      <D.23161>:
      {
        int ret;

        ret = pthread_mutex_unlock (&ldstr_section.mutex);
        if (ret != 0) goto <D.23162>; else goto <D.23163>;
        <D.23162>:
        monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
        <D.23163>:
        D.23164 = ret != 0;
        D.23165 = (long int) D.23164;
        D.23166 = __builtin_expect (D.23165, 0);
        if (D.23166 != 0) goto <D.23167>; else goto <D.23168>;
        <D.23167>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 5497, "ret == 0");
        <D.23168>:
      }
      D.23159 = o;
      return D.23159;
    }
  finally
    {
      str = {CLOBBER};
    }
}


mono_string_get_pinned (struct MonoString * str)
{
  int D.23171;
  int D.23172;
  int D.23173;
  unsigned int D.23174;
  unsigned int D.23175;
  struct MonoVTable * D.23176;
  long unsigned int D.23177;
  mono_unichar2 * D.23180;
  mono_unichar2 * D.23181;
  int D.23182;
  int D.23183;
  long unsigned int D.23184;
  int D.23185;
  struct MonoString * D.23186;
  int size;
  struct MonoString * news;

  D.23171 = mono_string_length (str);
  D.23172 = D.23171 + 1;
  D.23173 = D.23172 * 2;
  D.23174 = (unsigned int) D.23173;
  D.23175 = D.23174 + 24;
  size = (int) D.23175;
  D.23176 = MEM[(struct MonoObject *)str].vtable;
  D.23177 = (long unsigned int) size;
  news = mono_gc_alloc_pinned_obj (D.23176, D.23177);
  if (news != 0B) goto <D.23178>; else goto <D.23179>;
  <D.23178>:
  D.23180 = mono_string_chars (news);
  D.23181 = mono_string_chars (str);
  D.23182 = mono_string_length (str);
  D.23183 = D.23182 * 2;
  D.23184 = (long unsigned int) D.23183;
  memcpy (D.23180, D.23181, D.23184);
  D.23185 = mono_string_length (str);
  news->length = D.23185;
  <D.23179>:
  D.23186 = news;
  return D.23186;
}


__attribute__((visibility ("hidden")))
mono_field_static_get_value_for_thread (struct MonoInternalThread * thread, struct MonoVTable * vt, struct MonoClassField * field, void * value)
{
  struct MonoType * D.23188;
  short unsigned int D.23189;
  int D.23190;
  int D.23191;
  int D.23194;
  struct MonoDomain * D.23197;
  int D.23198;
  struct GHashTable * D.23201;
  long int addr.99;
  unsigned int D.23203;
  void * D.23205;
  sizetype D.23206;
  void * src;

  D.23188 = field->type;
  D.23189 = D.23188->attrs;
  D.23190 = (int) D.23189;
  D.23191 = D.23190 & 16;
  if (D.23191 == 0) goto <D.23192>; else goto <D.23193>;
  <D.23192>:
  monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "object.c", 3309, "field->type->attrs & FIELD_ATTRIBUTE_STATIC");
  return;
  <D.23193>:
  D.23188 = field->type;
  D.23189 = D.23188->attrs;
  D.23190 = (int) D.23189;
  D.23194 = D.23190 & 64;
  if (D.23194 != 0) goto <D.23195>; else goto <D.23196>;
  <D.23195>:
  D.23197 = vt->domain;
  get_default_field_value (D.23197, field, value);
  return;
  <D.23196>:
  D.23198 = field->offset;
  if (D.23198 == -1) goto <D.23199>; else goto <D.23200>;
  <D.23199>:
  {
    void * addr;

    D.23197 = vt->domain;
    D.23201 = D.23197->special_static_fields;
    addr = monoeg_g_hash_table_lookup (D.23201, field);
    addr.99 = (long int) addr;
    D.23203 = (unsigned int) addr.99;
    src = mono_get_special_static_data_for_thread (thread, D.23203);
  }
  goto <D.23204>;
  <D.23200>:
  D.23205 = mono_vtable_get_static_field_data (vt);
  D.23198 = field->offset;
  D.23206 = (sizetype) D.23198;
  src = D.23205 + D.23206;
  <D.23204>:
  D.23188 = field->type;
  set_value (D.23188, value, src, 1);
}


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

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


mono_property_set_value (struct MonoProperty * prop, void * obj, void * * params, struct MonoObject * * exc)
{
  struct MonoObject * (*<T13ab>) (struct MonoMethod *, void *, void * *, struct MonoObject * *) default_mono_runtime_invoke.100;
  struct MonoMethod * D.23211;

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


mono_property_get_value (struct MonoProperty * prop, void * obj, void * * params, struct MonoObject * * exc)
{
  struct MonoObject * D.23212;
  struct MonoObject * (*<T13ab>) (struct MonoMethod *, void *, void * *, struct MonoObject * *) default_mono_runtime_invoke.101;
  struct MonoMethod * D.23214;

  default_mono_runtime_invoke.101 = default_mono_runtime_invoke;
  D.23214 = prop->get;
  D.23212 = default_mono_runtime_invoke.101 (D.23214, obj, params, exc);
  return D.23212;
}


__attribute__((visibility ("hidden")))
mono_nullable_init (guint8 * buf, struct MonoObject * value, struct MonoClass * klass)
{
  long unsigned int D.23216;
  long unsigned int D.23217;
  _Bool D.23218;
  long int D.23219;
  long int D.23220;
  struct MonoClassField * D.23223;
  struct MonoType * D.23224;
  struct MonoClass * D.23225;
  _Bool D.23226;
  long int D.23227;
  long int D.23228;
  struct MonoClassField * D.23231;
  struct MonoType * D.23232;
  struct MonoClass * D.23233;
  struct MonoClass * D.23234;
  _Bool D.23235;
  long int D.23236;
  long int D.23237;
  int D.23240;
  sizetype D.23241;
  sizetype D.23242;
  guint8 * D.23243;
  _Bool D.23244;
  unsigned char D.23245;
  long unsigned int D.23248;
  long unsigned int D.23249;
  int D.23252;
  sizetype D.23253;
  sizetype D.23254;
  guint8 * D.23255;
  void * D.23256;
  void * D.23258;
  int D.23259;
  long unsigned int D.23260;
  int D.23262;
  long unsigned int D.23263;
  struct MonoClass * param_class;

  param_class = klass->cast_class;
  mono_class_setup_fields_locking (klass);
  D.23216 = BIT_FIELD_REF <*klass, 64, 256>;
  D.23217 = D.23216 & 67108864;
  D.23218 = D.23217 == 0;
  D.23219 = (long int) D.23218;
  D.23220 = __builtin_expect (D.23219, 0);
  if (D.23220 != 0) goto <D.23221>; else goto <D.23222>;
  <D.23221>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 3412, "klass->fields_inited");
  <D.23222>:
  D.23223 = klass->fields;
  D.23224 = D.23223->type;
  D.23225 = mono_class_from_mono_type (D.23224);
  D.23226 = D.23225 != param_class;
  D.23227 = (long int) D.23226;
  D.23228 = __builtin_expect (D.23227, 0);
  if (D.23228 != 0) goto <D.23229>; else goto <D.23230>;
  <D.23229>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 3414, "mono_class_from_mono_type (klass->fields [0].type) == param_class");
  <D.23230>:
  D.23223 = klass->fields;
  D.23231 = D.23223 + 32;
  D.23232 = D.23231->type;
  D.23233 = mono_class_from_mono_type (D.23232);
  D.23234 = mono_defaults.boolean_class;
  D.23235 = D.23233 != D.23234;
  D.23236 = (long int) D.23235;
  D.23237 = __builtin_expect (D.23236, 0);
  if (D.23237 != 0) goto <D.23238>; else goto <D.23239>;
  <D.23238>:
  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.23239>:
  D.23223 = klass->fields;
  D.23231 = D.23223 + 32;
  D.23240 = D.23231->offset;
  D.23241 = (sizetype) D.23240;
  D.23242 = D.23241 + 18446744073709551600;
  D.23243 = buf + D.23242;
  D.23244 = value != 0B;
  D.23245 = (unsigned char) D.23244;
  *D.23243 = D.23245;
  if (value != 0B) goto <D.23246>; else goto <D.23247>;
  <D.23246>:
  D.23248 = BIT_FIELD_REF <*param_class, 64, 256>;
  D.23249 = D.23248 & 68719476736;
  if (D.23249 != 0) goto <D.23250>; else goto <D.23251>;
  <D.23250>:
  D.23223 = klass->fields;
  D.23252 = D.23223->offset;
  D.23253 = (sizetype) D.23252;
  D.23254 = D.23253 + 18446744073709551600;
  D.23255 = buf + D.23254;
  D.23256 = mono_object_unbox (value);
  mono_gc_wbarrier_value_copy (D.23255, D.23256, 1, param_class);
  goto <D.23257>;
  <D.23251>:
  D.23223 = klass->fields;
  D.23252 = D.23223->offset;
  D.23253 = (sizetype) D.23252;
  D.23254 = D.23253 + 18446744073709551600;
  D.23255 = buf + D.23254;
  D.23258 = mono_object_unbox (value);
  D.23259 = mono_class_value_size (param_class, 0B);
  D.23260 = (long unsigned int) D.23259;
  mono_gc_memmove_atomic (D.23255, D.23258, D.23260);
  <D.23257>:
  goto <D.23261>;
  <D.23247>:
  D.23223 = klass->fields;
  D.23252 = D.23223->offset;
  D.23253 = (sizetype) D.23252;
  D.23254 = D.23253 + 18446744073709551600;
  D.23255 = buf + D.23254;
  D.23262 = mono_class_value_size (param_class, 0B);
  D.23263 = (long unsigned int) D.23262;
  mono_gc_bzero_atomic (D.23255, D.23263);
  <D.23261>:
}


__attribute__((visibility ("hidden")))
mono_nullable_box (guint8 * buf, struct MonoClass * klass)
{
  long unsigned int D.23264;
  long unsigned int D.23265;
  _Bool D.23266;
  long int D.23267;
  long int D.23268;
  struct MonoClassField * D.23271;
  struct MonoType * D.23272;
  struct MonoClass * D.23273;
  _Bool D.23274;
  long int D.23275;
  long int D.23276;
  struct MonoClassField * D.23279;
  struct MonoType * D.23280;
  struct MonoClass * D.23281;
  struct MonoClass * D.23282;
  _Bool D.23283;
  long int D.23284;
  long int D.23285;
  int D.23288;
  sizetype D.23289;
  sizetype D.23290;
  guint8 * D.23291;
  unsigned char D.23292;
  struct MonoDomain * D.23295;
  long unsigned int D.23296;
  long unsigned int D.23297;
  void * D.23300;
  int D.23301;
  sizetype D.23302;
  sizetype D.23303;
  guint8 * D.23304;
  void * D.23306;
  int D.23307;
  long unsigned int D.23308;
  struct MonoObject * D.23309;
  struct MonoClass * param_class;

  param_class = klass->cast_class;
  mono_class_setup_fields_locking (klass);
  D.23264 = BIT_FIELD_REF <*klass, 64, 256>;
  D.23265 = D.23264 & 67108864;
  D.23266 = D.23265 == 0;
  D.23267 = (long int) D.23266;
  D.23268 = __builtin_expect (D.23267, 0);
  if (D.23268 != 0) goto <D.23269>; else goto <D.23270>;
  <D.23269>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 3442, "klass->fields_inited");
  <D.23270>:
  D.23271 = klass->fields;
  D.23272 = D.23271->type;
  D.23273 = mono_class_from_mono_type (D.23272);
  D.23274 = D.23273 != param_class;
  D.23275 = (long int) D.23274;
  D.23276 = __builtin_expect (D.23275, 0);
  if (D.23276 != 0) goto <D.23277>; else goto <D.23278>;
  <D.23277>:
  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.23278>:
  D.23271 = klass->fields;
  D.23279 = D.23271 + 32;
  D.23280 = D.23279->type;
  D.23281 = mono_class_from_mono_type (D.23280);
  D.23282 = mono_defaults.boolean_class;
  D.23283 = D.23281 != D.23282;
  D.23284 = (long int) D.23283;
  D.23285 = __builtin_expect (D.23284, 0);
  if (D.23285 != 0) goto <D.23286>; else goto <D.23287>;
  <D.23286>:
  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.23287>:
  D.23271 = klass->fields;
  D.23279 = D.23271 + 32;
  D.23288 = D.23279->offset;
  D.23289 = (sizetype) D.23288;
  D.23290 = D.23289 + 18446744073709551600;
  D.23291 = buf + D.23290;
  D.23292 = *D.23291;
  if (D.23292 != 0) goto <D.23293>; else goto <D.23294>;
  <D.23293>:
  {
    struct MonoObject * o;

    D.23295 = mono_domain_get ();
    o = mono_object_new (D.23295, param_class);
    D.23296 = BIT_FIELD_REF <*param_class, 64, 256>;
    D.23297 = D.23296 & 68719476736;
    if (D.23297 != 0) goto <D.23298>; else goto <D.23299>;
    <D.23298>:
    D.23300 = mono_object_unbox (o);
    D.23271 = klass->fields;
    D.23301 = D.23271->offset;
    D.23302 = (sizetype) D.23301;
    D.23303 = D.23302 + 18446744073709551600;
    D.23304 = buf + D.23303;
    mono_gc_wbarrier_value_copy (D.23300, D.23304, 1, param_class);
    goto <D.23305>;
    <D.23299>:
    D.23306 = mono_object_unbox (o);
    D.23271 = klass->fields;
    D.23301 = D.23271->offset;
    D.23302 = (sizetype) D.23301;
    D.23303 = D.23302 + 18446744073709551600;
    D.23304 = buf + D.23303;
    D.23307 = mono_class_value_size (param_class, 0B);
    D.23308 = (long unsigned int) D.23307;
    mono_gc_memmove_atomic (D.23306, D.23304, D.23308);
    <D.23305>:
    D.23309 = o;
    return D.23309;
  }
  <D.23294>:
  D.23309 = 0B;
  return D.23309;
}


mono_get_delegate_invoke (struct MonoClass * klass)
{
  unsigned char D.23311;
  struct MonoMethod * D.23314;
  struct MonoMethod * im;

  mono_class_setup_methods (klass);
  D.23311 = klass->exception_type;
  if (D.23311 != 0) goto <D.23312>; else goto <D.23313>;
  <D.23312>:
  D.23314 = 0B;
  return D.23314;
  <D.23313>:
  im = mono_class_get_method_from_name (klass, "Invoke", -1);
  D.23314 = im;
  return D.23314;
}


mono_get_delegate_begin_invoke (struct MonoClass * klass)
{
  unsigned char D.23316;
  struct MonoMethod * D.23319;
  struct MonoMethod * im;

  mono_class_setup_methods (klass);
  D.23316 = klass->exception_type;
  if (D.23316 != 0) goto <D.23317>; else goto <D.23318>;
  <D.23317>:
  D.23319 = 0B;
  return D.23319;
  <D.23318>:
  im = mono_class_get_method_from_name (klass, "BeginInvoke", -1);
  D.23319 = im;
  return D.23319;
}


mono_get_delegate_end_invoke (struct MonoClass * klass)
{
  unsigned char D.23321;
  struct MonoMethod * D.23324;
  struct MonoMethod * im;

  mono_class_setup_methods (klass);
  D.23321 = klass->exception_type;
  if (D.23321 != 0) goto <D.23322>; else goto <D.23323>;
  <D.23322>:
  D.23324 = 0B;
  return D.23324;
  <D.23323>:
  im = mono_class_get_method_from_name (klass, "EndInvoke", -1);
  D.23324 = im;
  return D.23324;
}


mono_runtime_delegate_invoke (struct MonoObject * delegate, void * * params, struct MonoObject * * exc)
{
  struct MonoVTable * D.23326;
  char * D.23329;
  struct MonoObject * D.23330;
  struct MonoMethod * im;
  struct MonoClass * klass;

  D.23326 = delegate->vtable;
  klass = D.23326->klass;
  im = mono_get_delegate_invoke (klass);
  if (im == 0B) goto <D.23327>; else goto <D.23328>;
  <D.23327>:
  D.23329 = mono_type_get_full_name (klass);
  monoeg_g_log (0B, 4, "Could not lookup delegate invoke method for delegate %s", D.23329);
  <D.20038>:
  goto <D.20038>;
  <D.23328>:
  D.23330 = mono_runtime_invoke (im, delegate, params, exc);
  return D.23330;
}


mono_runtime_get_main_args ()
{
  char * * main_args.102;
  struct MonoArray * D.23335;
  struct MonoClass * D.23336;
  int num_main_args.103;
  long unsigned int D.23338;
  long unsigned int D.23339;
  long unsigned int D.23340;
  long unsigned int D.23341;
  char * * D.23342;
  char * D.23343;
  struct MonoString * D.23344;
  struct MonoArray * res;
  int i;
  struct MonoDomain * domain;

  domain = mono_domain_get ();
  main_args.102 = main_args;
  if (main_args.102 == 0B) goto <D.23333>; else goto <D.23334>;
  <D.23333>:
  D.23335 = 0B;
  return D.23335;
  <D.23334>:
  D.23336 = mono_defaults.string_class;
  num_main_args.103 = num_main_args;
  D.23338 = (long unsigned int) num_main_args.103;
  res = mono_array_new (domain, D.23336, D.23338);
  i = 0;
  goto <D.20049>;
  <D.20048>:
  {
    void * * __p;

    D.23339 = (long unsigned int) i;
    __p = mono_array_addr_with_size (res, 8, D.23339);
    main_args.102 = main_args;
    D.23340 = (long unsigned int) i;
    D.23341 = D.23340 * 8;
    D.23342 = main_args.102 + D.23341;
    D.23343 = *D.23342;
    D.23344 = mono_string_new (domain, D.23343);
    mono_gc_wbarrier_set_arrayref (res, __p, D.23344);
  }
  i = i + 1;
  <D.20049>:
  num_main_args.103 = num_main_args;
  if (i < num_main_args.103) goto <D.20048>; else goto <D.20050>;
  <D.20050>:
  D.23335 = res;
  return D.23335;
}


mono_runtime_run_main (struct MonoMethod * method, int argc, char * * argv, struct MonoObject * * exc)
{
  _Bool D.23346;
  long int D.23347;
  long int D.23348;
  struct MonoThread * D.23351;
  long unsigned int D.23352;
  long unsigned int D.23353;
  void * D.23354;
  char * D.23355;
  int D.23356;
  struct MonoClass * D.23359;
  struct MonoImage * D.23360;
  struct MonoAssembly * D.23361;
  char * D.23362;
  char * * main_args.104;
  long unsigned int D.23369;
  long unsigned int D.23370;
  char * * D.23371;
  char * D.23372;
  char * * D.23375;
  short unsigned int D.23378;
  struct MonoClass * D.23381;
  long unsigned int D.23382;
  long unsigned int D.23383;
  int D.23385;
  int i;
  struct MonoArray * args;
  struct MonoDomain * domain;
  gchar * utf8_fullpath;
  struct MonoMethodSignature * sig;

  args = 0B;
  domain = mono_domain_get ();
  D.23346 = method == 0B;
  D.23347 = (long int) D.23346;
  D.23348 = __builtin_expect (D.23347, 0);
  if (D.23348 != 0) goto <D.23349>; else goto <D.23350>;
  <D.23349>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 3601, "method != NULL");
  <D.23350>:
  D.23351 = mono_thread_current ();
  mono_thread_set_main (D.23351);
  D.23352 = (long unsigned int) argc;
  D.23353 = D.23352 * 8;
  D.23354 = monoeg_malloc0 (D.23353);
  main_args = D.23354;
  num_main_args = argc;
  D.23355 = *argv;
  D.23356 = monoeg_g_path_is_absolute (D.23355);
  if (D.23356 == 0) goto <D.23357>; else goto <D.23358>;
  <D.23357>:
  {
    gchar * basename;
    gchar * fullpath;

    D.23355 = *argv;
    basename = monoeg_g_path_get_basename (D.23355);
    D.23359 = method->klass;
    D.23360 = D.23359->image;
    D.23361 = D.23360->assembly;
    D.23362 = D.23361->basedir;
    fullpath = monoeg_g_build_path ("/", D.23362, basename, 0B);
    utf8_fullpath = mono_utf8_from_external (fullpath);
    if (utf8_fullpath == 0B) goto <D.23363>; else goto <D.23364>;
    <D.23363>:
    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.23364>:
    monoeg_g_free (fullpath);
    monoeg_g_free (basename);
  }
  goto <D.23365>;
  <D.23358>:
  D.23355 = *argv;
  utf8_fullpath = mono_utf8_from_external (D.23355);
  if (utf8_fullpath == 0B) goto <D.23366>; else goto <D.23367>;
  <D.23366>:
  D.23355 = *argv;
  monoeg_g_print ("\nCannot determine the text encoding for the assembly location: %s\n", D.23355);
  monoeg_g_print ("Please add the correct encoding to MONO_EXTERNAL_ENCODINGS and try again.\n");
  exit (-1);
  <D.23367>:
  <D.23365>:
  main_args.104 = main_args;
  *main_args.104 = utf8_fullpath;
  i = 1;
  goto <D.20073>;
  <D.20072>:
  {
    gchar * utf8_arg;

    D.23369 = (long unsigned int) i;
    D.23370 = D.23369 * 8;
    D.23371 = argv + D.23370;
    D.23372 = *D.23371;
    utf8_arg = mono_utf8_from_external (D.23372);
    if (utf8_arg == 0B) goto <D.23373>; else goto <D.23374>;
    <D.23373>:
    D.23369 = (long unsigned int) i;
    D.23370 = D.23369 * 8;
    D.23371 = argv + D.23370;
    D.23372 = *D.23371;
    monoeg_g_print ("\nCannot determine the text encoding for argument %d (%s).\n", i, D.23372);
    monoeg_g_print ("Please add the correct encoding to MONO_EXTERNAL_ENCODINGS and try again.\n");
    exit (-1);
    <D.23374>:
    main_args.104 = main_args;
    D.23369 = (long unsigned int) i;
    D.23370 = D.23369 * 8;
    D.23375 = main_args.104 + D.23370;
    *D.23375 = utf8_arg;
  }
  i = i + 1;
  <D.20073>:
  if (i < argc) goto <D.20072>; else goto <D.20074>;
  <D.20074>:
  argc = argc + -1;
  argv = argv + 8;
  sig = mono_method_signature (method);
  if (sig == 0B) goto <D.23376>; else goto <D.23377>;
  <D.23376>:
  monoeg_g_print ("Unable to load Main method.\n");
  exit (-1);
  <D.23377>:
  D.23378 = sig->param_count;
  if (D.23378 != 0) goto <D.23379>; else goto <D.23380>;
  <D.23379>:
  D.23381 = mono_defaults.string_class;
  D.23382 = (long unsigned int) argc;
  args = mono_array_new (domain, D.23381, D.23382);
  i = 0;
  goto <D.20079>;
  <D.20078>:
  {
    gchar * str;
    struct MonoString * arg;

    D.23369 = (long unsigned int) i;
    D.23370 = D.23369 * 8;
    D.23371 = argv + D.23370;
    D.23372 = *D.23371;
    str = mono_utf8_from_external (D.23372);
    arg = mono_string_new (domain, str);
    {
      void * * __p;

      D.23383 = (long unsigned int) i;
      __p = mono_array_addr_with_size (args, 8, D.23383);
      mono_gc_wbarrier_set_arrayref (args, __p, arg);
    }
    monoeg_g_free (str);
  }
  i = i + 1;
  <D.20079>:
  if (i < argc) goto <D.20078>; else goto <D.20080>;
  <D.20080>:
  goto <D.23384>;
  <D.23380>:
  D.23381 = mono_defaults.string_class;
  args = mono_array_new (domain, D.23381, 0);
  <D.23384>:
  D.23359 = method->klass;
  D.23360 = D.23359->image;
  D.23361 = D.23360->assembly;
  mono_assembly_set_main (D.23361);
  D.23385 = mono_runtime_exec_main (method, args, exc);
  return D.23385;
}


__attribute__((visibility ("hidden")))
mono_object_xdomain_representation (struct MonoObject * obj, struct MonoDomain * target_domain, struct MonoObject * * exc)
{
  struct MonoVTable * D.23387;
  struct MonoClass * D.23388;
  long unsigned int D.23389;
  long unsigned int D.23390;
  struct MonoDomain * D.23394;
  int failure.105;
  struct MonoObject * D.23400;
  struct MonoObject * deserialized;
  gboolean failure;

  try
    {
      deserialized = 0B;
      failure = 0;
      *exc = 0B;
      D.23387 = obj->vtable;
      D.23388 = D.23387->klass;
      D.23389 = BIT_FIELD_REF <*D.23388, 64, 256>;
      D.23390 = D.23389 & 2199023255552;
      if (D.23390 != 0) goto <D.23391>; else goto <D.23392>;
      <D.23391>:
      deserialized = make_transparent_proxy (obj, &failure, exc);
      goto <D.23393>;
      <D.23392>:
      {
        struct MonoDomain * domain;
        struct MonoObject * serialized;

        domain = mono_domain_get ();
        D.23387 = obj->vtable;
        D.23394 = D.23387->domain;
        mono_domain_set_internal_with_options (D.23394, 0);
        serialized = serialize_object (obj, &failure, exc);
        mono_domain_set_internal_with_options (target_domain, 0);
        failure.105 = failure;
        if (failure.105 == 0) goto <D.23396>; else goto <D.23397>;
        <D.23396>:
        deserialized = deserialize_object (serialized, &failure, exc);
        <D.23397>:
        if (domain != target_domain) goto <D.23398>; else goto <D.23399>;
        <D.23398>:
        mono_domain_set_internal_with_options (domain, 0);
        <D.23399>:
      }
      <D.23393>:
      D.23400 = deserialized;
      return D.23400;
    }
  finally
    {
      failure = {CLOBBER};
    }
}


make_transparent_proxy (struct MonoObject * obj, gboolean * failure, struct MonoObject * * exc)
{
  struct MonoMethod * get_proxy_method.106;
  struct MonoClass * D.23406;
  struct MonoMethod * get_proxy_method.107;
  struct MonoVTable * D.23408;
  struct MonoClass * D.23409;
  long unsigned int D.23410;
  long unsigned int D.23411;
  _Bool D.23412;
  long int D.23413;
  long int D.23414;
  struct MonoType * D.23417;
  struct MonoReflectionType * * D.23418;
  struct MonoObject * * D.23419;
  struct MonoObject * D.23420;
  struct MonoObject * D.23423;
  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.106 = get_proxy_method;
  if (get_proxy_method.106 == 0B) goto <D.23404>; else goto <D.23405>;
  <D.23404>:
  D.23406 = mono_defaults.real_proxy_class;
  get_proxy_method.107 = mono_class_get_method_from_name (D.23406, "GetTransparentProxy", 0);
  get_proxy_method = get_proxy_method.107;
  <D.23405>:
  D.23408 = obj->vtable;
  D.23409 = D.23408->klass;
  D.23410 = BIT_FIELD_REF <*D.23409, 64, 256>;
  D.23411 = D.23410 & 2199023255552;
  D.23412 = D.23411 == 0;
  D.23413 = (long int) D.23412;
  D.23414 = __builtin_expect (D.23413, 0);
  if (D.23414 != 0) goto <D.23415>; else goto <D.23416>;
  <D.23415>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 3751, "mono_class_is_marshalbyref (obj->vtable->klass)");
  <D.23416>:
  D.23406 = mono_defaults.real_proxy_class;
  real_proxy = mono_object_new (domain, D.23406);
  D.23408 = obj->vtable;
  D.23409 = D.23408->klass;
  D.23417 = &D.23409->byval_arg;
  reflection_type = mono_type_get_object (domain, D.23417);
  D.23418 = &real_proxy->class_to_proxy;
  mono_gc_wbarrier_set_field (real_proxy, D.23418, reflection_type);
  D.23419 = &real_proxy->unwrapped_server;
  mono_gc_wbarrier_set_field (real_proxy, D.23419, obj);
  *exc = 0B;
  get_proxy_method.106 = get_proxy_method;
  transparent_proxy = mono_runtime_invoke (get_proxy_method.106, real_proxy, 0B, exc);
  D.23420 = *exc;
  if (D.23420 != 0B) goto <D.23421>; else goto <D.23422>;
  <D.23421>:
  *failure = 1;
  <D.23422>:
  D.23423 = transparent_proxy;
  return D.23423;
}


serialize_object (struct MonoObject * obj, gboolean * failure, struct MonoObject * * exc)
{
  struct MonoMethod * serialize_method.108;
  struct MonoImage * D.23428;
  struct MonoMethod * serialize_method.109;
  struct MonoObject * D.23432;
  struct MonoVTable * D.23433;
  struct MonoClass * D.23434;
  long unsigned int D.23435;
  long unsigned int D.23436;
  _Bool D.23437;
  long int D.23438;
  long int D.23439;
  struct MonoObject * D.23442;
  static struct MonoMethod * serialize_method;
  void * params[1];
  struct MonoObject * array;

  try
    {
      serialize_method.108 = serialize_method;
      if (serialize_method.108 == 0B) goto <D.23426>; else goto <D.23427>;
      <D.23426>:
      {
        struct MonoClass * klass;

        D.23428 = mono_defaults.corlib;
        klass = mono_class_from_name (D.23428, "System.Runtime.Remoting", "RemotingServices");
        serialize_method.109 = mono_class_get_method_from_name (klass, "SerializeCallData", -1);
        serialize_method = serialize_method.109;
      }
      <D.23427>:
      serialize_method.108 = serialize_method;
      if (serialize_method.108 == 0B) goto <D.23430>; else goto <D.23431>;
      <D.23430>:
      *failure = 1;
      D.23432 = 0B;
      return D.23432;
      <D.23431>:
      D.23433 = obj->vtable;
      D.23434 = D.23433->klass;
      D.23435 = BIT_FIELD_REF <*D.23434, 64, 256>;
      D.23436 = D.23435 & 2199023255552;
      D.23437 = D.23436 != 0;
      D.23438 = (long int) D.23437;
      D.23439 = __builtin_expect (D.23438, 0);
      if (D.23439 != 0) goto <D.23440>; else goto <D.23441>;
      <D.23440>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 3700, "!mono_class_is_marshalbyref (mono_object_class (obj))");
      <D.23441>:
      params[0] = obj;
      *exc = 0B;
      serialize_method.108 = serialize_method;
      array = mono_runtime_invoke (serialize_method.108, 0B, &params, exc);
      D.23442 = *exc;
      if (D.23442 != 0B) goto <D.23443>; else goto <D.23444>;
      <D.23443>:
      *failure = 1;
      <D.23444>:
      D.23432 = array;
      return D.23432;
    }
  finally
    {
      params = {CLOBBER};
    }
}


deserialize_object (struct MonoObject * obj, gboolean * failure, struct MonoObject * * exc)
{
  struct MonoMethod * deserialize_method.110;
  struct MonoImage * D.23450;
  struct MonoMethod * deserialize_method.111;
  struct MonoObject * D.23454;
  struct MonoObject * D.23455;
  static struct MonoMethod * deserialize_method;
  void * params[1];
  struct MonoObject * result;

  try
    {
      deserialize_method.110 = deserialize_method;
      if (deserialize_method.110 == 0B) goto <D.23448>; else goto <D.23449>;
      <D.23448>:
      {
        struct MonoClass * klass;

        D.23450 = mono_defaults.corlib;
        klass = mono_class_from_name (D.23450, "System.Runtime.Remoting", "RemotingServices");
        deserialize_method.111 = mono_class_get_method_from_name (klass, "DeserializeCallData", -1);
        deserialize_method = deserialize_method.111;
      }
      <D.23449>:
      deserialize_method.110 = deserialize_method;
      if (deserialize_method.110 == 0B) goto <D.23452>; else goto <D.23453>;
      <D.23452>:
      *failure = 1;
      D.23454 = 0B;
      return D.23454;
      <D.23453>:
      params[0] = obj;
      *exc = 0B;
      deserialize_method.110 = deserialize_method;
      result = mono_runtime_invoke (deserialize_method.110, 0B, &params, exc);
      D.23455 = *exc;
      if (D.23455 != 0B) goto <D.23456>; else goto <D.23457>;
      <D.23456>:
      *failure = 1;
      <D.23457>:
      D.23454 = result;
      return D.23454;
    }
  finally
    {
      params = {CLOBBER};
    }
}


__attribute__((visibility ("hidden")))
mono_runtime_unhandled_exception_policy_set (MonoRuntimeUnhandledExceptionPolicy policy)
{
  runtime_unhandled_exception_policy = policy;
}


__attribute__((visibility ("hidden")))
mono_runtime_unhandled_exception_policy_get ()
{
  MonoRuntimeUnhandledExceptionPolicy D.23460;

  D.23460 = runtime_unhandled_exception_policy;
  return D.23460;
}


mono_unhandled_exception (struct MonoObject * exc)
{
  struct MonoClass * D.23462;
  _Bool D.23463;
  long int D.23464;
  long int D.23465;
  struct MonoVTable * D.23468;
  struct MonoClass * D.23469;
  struct MonoClass * D.23470;
  int iftmp.112;
  struct MonoThread * main_thread.113;
  struct MonoInternalThread * D.23480;
  struct _MonoInternalThread * D.23481;
  <unnamed type> D.23482;
  struct MonoAppDomain * D.23483;
  int D.23484;
  sizetype D.23485;
  struct MonoObject * * D.23486;
  struct MonoAppDomain * D.23489;
  struct MonoObject * * D.23490;
  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.23462 = mono_defaults.appdomain_class;
  field = mono_class_get_field_from_name (D.23462, "UnhandledException");
  D.23463 = field == 0B;
  D.23464 = (long int) D.23463;
  D.23465 = __builtin_expect (D.23464, 0);
  if (D.23465 != 0) goto <D.23466>; else goto <D.23467>;
  <D.23466>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 3940, "field");
  <D.23467>:
  D.23468 = exc->vtable;
  D.23469 = D.23468->klass;
  D.23470 = mono_defaults.threadabortexception_class;
  if (D.23469 != D.23470) goto <D.23471>; else goto <D.23472>;
  <D.23471>:
  {
    gboolean abort_process;

    main_thread.113 = main_thread;
    if (main_thread.113 != 0B) goto <D.23479>; else goto <D.23474>;
    <D.23479>:
    D.23480 = mono_thread_internal_current ();
    main_thread.113 = main_thread;
    D.23481 = main_thread.113->internal_thread;
    if (D.23480 == D.23481) goto <D.23475>; else goto <D.23474>;
    <D.23474>:
    D.23482 = mono_runtime_unhandled_exception_policy_get ();
    if (D.23482 == 1) goto <D.23475>; else goto <D.23476>;
    <D.23475>:
    iftmp.112 = 1;
    goto <D.23477>;
    <D.23476>:
    iftmp.112 = 0;
    <D.23477>:
    abort_process = iftmp.112;
    D.23483 = root_domain->domain;
    D.23484 = field->offset;
    D.23485 = (sizetype) D.23484;
    D.23486 = D.23483 + D.23485;
    root_appdomain_delegate = *D.23486;
    if (current_domain != root_domain) goto <D.23487>; else goto <D.23488>;
    <D.23487>:
    D.23489 = current_domain->domain;
    D.23484 = field->offset;
    D.23485 = (sizetype) D.23484;
    D.23490 = D.23489 + D.23485;
    current_appdomain_delegate = *D.23490;
    goto <D.23491>;
    <D.23488>:
    current_appdomain_delegate = 0B;
    <D.23491>:
    if (current_appdomain_delegate == 0B) goto <D.23494>; else goto <D.23492>;
    <D.23494>:
    if (root_appdomain_delegate == 0B) goto <D.23495>; else goto <D.23492>;
    <D.23495>:
    if (abort_process != 0) goto <D.23496>; else goto <D.23497>;
    <D.23496>:
    mono_environment_exitcode_set (1);
    <D.23497>:
    mono_print_unhandled_exception (exc);
    goto <D.23493>;
    <D.23492>:
    if (root_appdomain_delegate != 0B) goto <D.23498>; else goto <D.23499>;
    <D.23498>:
    call_unhandled_exception_delegate (root_domain, root_appdomain_delegate, exc);
    <D.23499>:
    if (current_appdomain_delegate != 0B) goto <D.23500>; else goto <D.23501>;
    <D.23500>:
    call_unhandled_exception_delegate (current_domain, current_appdomain_delegate, exc);
    <D.23501>:
    <D.23493>:
  }
  <D.23472>:
}


call_unhandled_exception_delegate (struct MonoDomain * domain, struct MonoObject * delegate, struct MonoObject * exc)
{
  struct MonoAppDomain * D.23504;
  struct MonoVTable * D.23505;
  struct MonoDomain * D.23506;
  _Bool D.23507;
  long int D.23508;
  long int D.23509;
  struct MonoVTable * D.23512;
  struct MonoDomain * D.23513;
  struct MonoObject * serialization_exc.114;
  _Bool D.23521;
  long int D.23522;
  long int D.23523;
  struct MonoImage * D.23527;
  _Bool D.23528;
  long int D.23529;
  long int D.23530;
  struct MonoObject * D.23533;
  struct MonoObject * e.115;
  struct MonoString * D.23539;
  int D.23540;
  struct MonoObject * e;
  void * pa[2];
  struct MonoDomain * current_domain;

  try
    {
      e = 0B;
      current_domain = mono_domain_get ();
      if (domain != current_domain) goto <D.23502>; else goto <D.23503>;
      <D.23502>:
      mono_domain_set_internal_with_options (domain, 0);
      <D.23503>:
      D.23504 = domain->domain;
      D.23505 = MEM[(struct MonoObject *)D.23504].vtable;
      D.23506 = D.23505->domain;
      D.23507 = D.23506 != domain;
      D.23508 = (long int) D.23507;
      D.23509 = __builtin_expect (D.23508, 0);
      if (D.23509 != 0) goto <D.23510>; else goto <D.23511>;
      <D.23510>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 3850, "domain == mono_object_domain (domain->domain)");
      <D.23511>:
      D.23512 = exc->vtable;
      D.23513 = D.23512->domain;
      if (D.23513 != domain) goto <D.23514>; else goto <D.23515>;
      <D.23514>:
      {
        struct MonoObject * serialization_exc;

        try
          {
            exc = mono_object_xdomain_representation (exc, domain, &serialization_exc);
            if (exc == 0B) goto <D.23516>; else goto <D.23517>;
            <D.23516>:
            serialization_exc.114 = serialization_exc;
            if (serialization_exc.114 != 0B) goto <D.23519>; else goto <D.23520>;
            <D.23519>:
            {
              struct MonoObject * dummy;

              try
                {
                  serialization_exc.114 = serialization_exc;
                  exc = mono_object_xdomain_representation (serialization_exc.114, domain, &dummy);
                  D.23521 = exc == 0B;
                  D.23522 = (long int) D.23521;
                  D.23523 = __builtin_expect (D.23522, 0);
                  if (D.23523 != 0) goto <D.23524>; else goto <D.23525>;
                  <D.23524>:
                  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 3860, "exc");
                  <D.23525>:
                }
              finally
                {
                  dummy = {CLOBBER};
                }
            }
            goto <D.23526>;
            <D.23520>:
            D.23527 = mono_get_corlib ();
            exc = mono_exception_from_name_msg (D.23527, "System.Runtime.Serialization", "SerializationException", "Could not serialize unhandled exception.");
            <D.23526>:
            <D.23517>:
          }
        finally
          {
            serialization_exc = {CLOBBER};
          }
      }
      <D.23515>:
      D.23512 = exc->vtable;
      D.23513 = D.23512->domain;
      D.23528 = D.23513 != domain;
      D.23529 = (long int) D.23528;
      D.23530 = __builtin_expect (D.23529, 0);
      if (D.23530 != 0) goto <D.23531>; else goto <D.23532>;
      <D.23531>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 3868, "mono_object_domain (exc) == domain");
      <D.23532>:
      D.23504 = domain->domain;
      pa[0] = D.23504;
      D.23533 = create_unhandled_exception_eventargs (exc);
      pa[1] = D.23533;
      mono_runtime_delegate_invoke (delegate, &pa, &e);
      if (domain != current_domain) goto <D.23534>; else goto <D.23535>;
      <D.23534>:
      mono_domain_set_internal_with_options (current_domain, 0);
      <D.23535>:
      e.115 = e;
      if (e.115 != 0B) goto <D.23537>; else goto <D.23538>;
      <D.23537>:
      {
        struct MonoError error;
        gchar * msg;

        try
          {
            e.115 = e;
            D.23539 = MEM[(struct MonoException *)e.115].message;
            msg = mono_string_to_utf8_checked (D.23539, &error);
            D.23540 = mono_error_ok (&error);
            if (D.23540 == 0) goto <D.23541>; else goto <D.23542>;
            <D.23541>:
            monoeg_g_log (0B, 16, "Exception inside UnhandledException handler with invalid message (Invalid characters)\n");
            mono_error_cleanup (&error);
            goto <D.23543>;
            <D.23542>:
            monoeg_g_log (0B, 16, "exception inside UnhandledException handler: %s\n", msg);
            monoeg_g_free (msg);
            <D.23543>:
          }
        finally
          {
            error = {CLOBBER};
          }
      }
      <D.23538>:
    }
  finally
    {
      e = {CLOBBER};
      pa = {CLOBBER};
    }
}


create_unhandled_exception_eventargs (struct MonoObject * exc)
{
  struct MonoImage * D.23544;
  _Bool D.23545;
  long int D.23546;
  long int D.23547;
  _Bool D.23550;
  long int D.23551;
  long int D.23552;
  struct MonoDomain * D.23555;
  struct MonoObject * D.23556;
  struct MonoClass * klass;
  void * args[2];
  struct MonoMethod * method;
  MonoBoolean is_terminating;
  struct MonoObject * obj;

  try
    {
      method = 0B;
      is_terminating = 1;
      D.23544 = mono_defaults.corlib;
      klass = mono_class_from_name (D.23544, "System", "UnhandledExceptionEventArgs");
      D.23545 = klass == 0B;
      D.23546 = (long int) D.23545;
      D.23547 = __builtin_expect (D.23546, 0);
      if (D.23547 != 0) goto <D.23548>; else goto <D.23549>;
      <D.23548>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 3823, "klass");
      <D.23549>:
      mono_class_init (klass);
      method = mono_class_get_method_from_name_flags (klass, ".ctor", 2, 6);
      D.23550 = method == 0B;
      D.23551 = (long int) D.23550;
      D.23552 = __builtin_expect (D.23551, 0);
      if (D.23552 != 0) goto <D.23553>; else goto <D.23554>;
      <D.23553>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 3829, "method");
      <D.23554>:
      args[0] = exc;
      args[1] = &is_terminating;
      D.23555 = mono_domain_get ();
      obj = mono_object_new (D.23555, klass);
      mono_runtime_invoke (method, obj, &args, 0B);
      D.23556 = obj;
      return D.23556;
    }
  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.23559;
  long int D.23560;
  long int D.23561;
  struct MonoVTable * D.23564;
  struct MonoAssembly * D.23565;
  struct MonoClass * D.23568;
  struct MonoImage * D.23569;
  struct MonoAppDomainSetup * D.23570;
  struct MonoString * D.23571;
  struct MonoString * * D.23574;
  char * D.23575;
  struct MonoString * D.23576;
  struct MonoString * D.23577;
  struct MonoImage * D.23580;
  char * D.23581;
  struct MonoString * * D.23582;
  struct MonoString * D.23583;
  struct MonoClass * stathread_attribute.116;
  struct MonoImage * D.23589;
  struct MonoClass * stathread_attribute.117;
  int D.23591;
  struct MonoMethodSignature * D.23598;
  struct MonoType * D.23599;
  unsigned char D.23600;
  struct MonoObject * D.23607;
  guint32 * D.23608;
  unsigned int D.23609;
  int D.23615;
  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.23559 = args == 0B;
      D.23560 = (long int) D.23559;
      D.23561 = __builtin_expect (D.23560, 0);
      if (D.23561 != 0) goto <D.23562>; else goto <D.23563>;
      <D.23562>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 4008, "args");
      <D.23563>:
      pa[0] = args;
      D.23564 = MEM[(struct MonoObject *)args].vtable;
      domain = D.23564->domain;
      D.23565 = domain->entry_assembly;
      if (D.23565 == 0B) goto <D.23566>; else goto <D.23567>;
      <D.23566>:
      {
        gchar * str;
        struct MonoAssembly * assembly;

        D.23568 = method->klass;
        D.23569 = D.23568->image;
        assembly = D.23569->assembly;
        domain->entry_assembly = assembly;
        D.23570 = domain->setup;
        D.23571 = D.23570->application_base;
        if (D.23571 == 0B) goto <D.23572>; else goto <D.23573>;
        <D.23572>:
        D.23570 = domain->setup;
        D.23570 = domain->setup;
        D.23574 = &D.23570->application_base;
        D.23575 = assembly->basedir;
        D.23576 = mono_string_new (domain, D.23575);
        mono_gc_wbarrier_set_field (D.23570, D.23574, D.23576);
        <D.23573>:
        D.23570 = domain->setup;
        D.23577 = D.23570->configuration_file;
        if (D.23577 == 0B) goto <D.23578>; else goto <D.23579>;
        <D.23578>:
        D.23580 = assembly->image;
        D.23581 = D.23580->name;
        str = monoeg_g_strconcat (D.23581, ".config", 0B);
        D.23570 = domain->setup;
        D.23570 = domain->setup;
        D.23582 = &D.23570->configuration_file;
        D.23583 = mono_string_new (domain, str);
        mono_gc_wbarrier_set_field (D.23570, D.23582, D.23583);
        monoeg_g_free (str);
        mono_set_private_bin_path_from_config (domain);
        <D.23579>:
      }
      <D.23567>:
      cinfo = mono_custom_attrs_from_method (method);
      if (cinfo != 0B) goto <D.23584>; else goto <D.23585>;
      <D.23584>:
      {
        static struct MonoClass * stathread_attribute = 0B;

        stathread_attribute.116 = stathread_attribute;
        if (stathread_attribute.116 == 0B) goto <D.23587>; else goto <D.23588>;
        <D.23587>:
        D.23589 = mono_defaults.corlib;
        stathread_attribute.117 = mono_class_from_name (D.23589, "System", "STAThreadAttribute");
        stathread_attribute = stathread_attribute.117;
        <D.23588>:
        stathread_attribute.116 = stathread_attribute;
        has_stathread_attribute = mono_custom_attrs_has_attr (cinfo, stathread_attribute.116);
        D.23591 = cinfo->cached;
        if (D.23591 == 0) goto <D.23592>; else goto <D.23593>;
        <D.23592>:
        mono_custom_attrs_free (cinfo);
        <D.23593>:
      }
      goto <D.23594>;
      <D.23585>:
      has_stathread_attribute = 0;
      <D.23594>:
      if (has_stathread_attribute != 0) goto <D.23595>; else goto <D.23596>;
      <D.23595>:
      thread->apartment_state = 0;
      goto <D.23597>;
      <D.23596>:
      thread->apartment_state = 1;
      <D.23597>:
      mono_thread_init_apartment_state ();
      D.23598 = mono_method_signature (method);
      D.23599 = D.23598->ret;
      D.23600 = D.23599->type;
      if (D.23600 == 8) goto <D.23601>; else goto <D.23602>;
      <D.23601>:
      {
        struct MonoObject * res;

        res = mono_runtime_invoke (method, 0B, &pa, exc);
        if (exc == 0B) goto <D.23603>; else goto <D.23606>;
        <D.23606>:
        D.23607 = *exc;
        if (D.23607 == 0B) goto <D.23603>; else goto <D.23604>;
        <D.23603>:
        D.23608 = res + 16;
        D.23609 = *D.23608;
        rval = (int) D.23609;
        goto <D.23605>;
        <D.23604>:
        rval = -1;
        <D.23605>:
        mono_environment_exitcode_set (rval);
      }
      goto <D.23610>;
      <D.23602>:
      mono_runtime_invoke (method, 0B, &pa, exc);
      if (exc == 0B) goto <D.23611>; else goto <D.23614>;
      <D.23614>:
      D.23607 = *exc;
      if (D.23607 == 0B) goto <D.23611>; else goto <D.23612>;
      <D.23611>:
      rval = 0;
      goto <D.23613>;
      <D.23612>:
      rval = -1;
      mono_environment_exitcode_set (rval);
      <D.23613>:
      <D.23610>:
      D.23615 = rval;
      return D.23615;
    }
  finally
    {
      pa = {CLOBBER};
    }
}


__attribute__((visibility ("hidden")))
mono_install_runtime_invoke (struct MonoObject * (*MonoInvokeFunc) (struct MonoMethod *, void *, void * *, struct MonoObject * *) func)
{
  struct MonoObject * (*<T13ab>) (struct MonoMethod *, void *, void * *, struct MonoObject * *) iftmp.118;

  if (func != 0B) goto <D.23619>; else goto <D.23620>;
  <D.23619>:
  iftmp.118 = func;
  goto <D.23621>;
  <D.23620>:
  iftmp.118 = dummy_mono_runtime_invoke;
  <D.23621>:
  default_mono_runtime_invoke = iftmp.118;
}


mono_runtime_invoke_array (struct MonoMethod * method, void * obj, struct MonoArray * params, struct MonoObject * * exc)
{
  long unsigned int D.23624;
  long unsigned int D.23625;
  unsigned char D.23626;
  int D.23627;
  struct MonoType * D.23631;
  struct MonoClass * D.23632;
  int D.23633;
  long unsigned int D.23635;
  long unsigned int D.23636;
  void * * D.23637;
  long unsigned int D.23638;
  char * D.23639;
  struct MonoObject * D.23640;
  long unsigned int D.23641;
  long unsigned int D.23642;
  char * D.23645;
  struct MonoObject * D.23646;
  struct MonoDomain * D.23649;
  struct MonoClass * D.23650;
  struct MonoObject * D.23651;
  char * D.23654;
  struct MonoDomain * D.23655;
  struct MonoVTable * D.23656;
  struct MonoClass * D.23657;
  void * D.23658;
  char * D.23659;
  struct MonoObject * D.23660;
  void * D.23661;
  char * D.23664;
  char * D.23666;
  struct MonoObject * D.23667;
  struct MonoGenericClass * D.23670;
  struct MonoClass * D.23671;
  char * D.23673;
  struct MonoVTable * D.23677;
  struct MonoClass * D.23678;
  struct MonoClass * D.23679;
  _Bool D.23680;
  long int D.23681;
  long int D.23682;
  void * D.23685;
  unsigned char D.23686;
  int D.23687;
  long unsigned int D.23688;
  const char * D.23690;
  int D.23691;
  struct MonoClass * D.23693;
  struct MonoClass * D.23694;
  int D.23696;
  _Bool D.23699;
  long int D.23700;
  long int D.23701;
  struct MonoObject * D.23706;
  struct MonoDomain * D.23707;
  struct MonoClass * D.23708;
  void * D.23709;
  struct MonoDomain * D.23712;
  _Bool D.23713;
  long int D.23714;
  long int D.23715;
  struct MonoVTable * D.23718;
  struct MonoClass * D.23719;
  struct MonoClass * D.23720;
  struct MonoMethod * iftmp.119;
  short int D.23724;
  struct MonoMethod * * D.23727;
  long unsigned int D.23728;
  long unsigned int D.23729;
  struct MonoMethod * * D.23730;
  long unsigned int D.23732;
  long unsigned int D.23733;
  struct MonoDomain * D.23740;
  int D.23741;
  struct MonoDomain * D.23744;
  void * D.23745;
  struct MonoDomain * D.23746;
  struct MonoObject * D.23747;
  struct MonoType * D.23748;
  unsigned char D.23749;
  struct MonoClass * pointer_class.122;
  struct MonoClass * tmp_klass.120;
  struct MonoImage * D.23757;
  struct MonoClass * tmp_klass.121;
  _Bool D.23759;
  long int D.23760;
  long int D.23761;
  struct MonoMethod * box_method.123;
  struct MonoMethod * box_method.124;
  struct MonoVTable * D.23768;
  struct MonoClass * D.23769;
  _Bool D.23770;
  long int D.23771;
  long int D.23772;
  void * D.23775;
  struct MonoDomain * D.23776;
  struct MonoReflectionType * D.23777;
  struct MonoObject * box_exc.125;
  _Bool D.23779;
  long int D.23780;
  long int D.23781;
  long unsigned int D.23786;
  long unsigned int D.23787;
  struct MonoClass * D.23790;
  int D.23791;
  void * D.23794;
  long unsigned int D.23795;
  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.23622>; else goto <D.23623>;
  <D.23622>:
  D.23624 = mono_array_length (params);
  D.23625 = D.23624 * 8;
  pa = __builtin_alloca (D.23625);
  i = 0;
  goto <D.20221>;
  <D.20220>:
  {
    struct MonoType * t;

    t = sig->params[i];
    again:
    D.23626 = t->type;
    D.23627 = (int) D.23626;
    switch (D.23627) <default: <D.20218>, case 2: <D.20192>, case 3: <D.20195>, case 4: <D.20191>, case 5: <D.20190>, case 6: <D.20194>, case 7: <D.20193>, case 8: <D.20199>, case 9: <D.20198>, case 10: <D.20201>, case 11: <D.20200>, case 12: <D.20202>, case 13: <D.20203>, case 14: <D.20210>, case 15: <D.20216>, case 17: <D.20204>, case 18: <D.20212>, case 20: <D.20213>, case 21: <D.20215>, case 24: <D.20197>, case 25: <D.20196>, case 28: <D.20211>, case 29: <D.20214>>
    <D.20190>:
    <D.20191>:
    <D.20192>:
    <D.20193>:
    <D.20194>:
    <D.20195>:
    <D.20196>:
    <D.20197>:
    <D.20198>:
    <D.20199>:
    <D.20200>:
    <D.20201>:
    <D.20202>:
    <D.20203>:
    <D.20204>:
    D.23626 = t->type;
    if (D.23626 == 17) goto <D.23630>; else goto <D.23628>;
    <D.23630>:
    D.23631 = sig->params[i];
    D.23632 = mono_class_from_mono_type (D.23631);
    D.23633 = mono_class_is_nullable (D.23632);
    if (D.23633 != 0) goto <D.23634>; else goto <D.23628>;
    <D.23634>:
    D.23635 = (long unsigned int) i;
    D.23636 = D.23635 * 8;
    D.23637 = pa + D.23636;
    D.23638 = (long unsigned int) i;
    D.23639 = mono_array_addr_with_size (params, 8, D.23638);
    D.23640 = MEM[(struct MonoObject * *)D.23639];
    *D.23637 = D.23640;
    D.23641 = BIT_FIELD_REF <*t, 64, 64>;
    D.23642 = D.23641 & 8589934592;
    if (D.23642 != 0) goto <D.23643>; else goto <D.23644>;
    <D.23643>:
    has_byref_nullables = 1;
    <D.23644>:
    goto <D.23629>;
    <D.23628>:
    D.23638 = (long unsigned int) i;
    D.23645 = mono_array_addr_with_size (params, 8, D.23638);
    D.23646 = MEM[(struct MonoObject * *)D.23645];
    if (D.23646 == 0B) goto <D.23647>; else goto <D.23648>;
    <D.23647>:
    {
      void * * __p;

      D.23638 = (long unsigned int) i;
      __p = mono_array_addr_with_size (params, 8, D.23638);
      D.23649 = mono_domain_get ();
      D.23631 = sig->params[i];
      D.23650 = mono_class_from_mono_type (D.23631);
      D.23651 = mono_object_new (D.23649, D.23650);
      mono_gc_wbarrier_set_arrayref (params, __p, D.23651);
    }
    <D.23648>:
    D.23641 = BIT_FIELD_REF <*t, 64, 64>;
    D.23642 = D.23641 & 8589934592;
    if (D.23642 != 0) goto <D.23652>; else goto <D.23653>;
    <D.23652>:
    {
      struct MonoObject * orig;
      struct MonoObject * copy;

      D.23638 = (long unsigned int) i;
      D.23654 = mono_array_addr_with_size (params, 8, D.23638);
      orig = MEM[(struct MonoObject * *)D.23654];
      D.23655 = mono_domain_get ();
      D.23656 = orig->vtable;
      D.23657 = D.23656->klass;
      D.23658 = mono_object_unbox (orig);
      copy = mono_value_box (D.23655, D.23657, D.23658);
      {
        void * * __p;

        D.23638 = (long unsigned int) i;
        __p = mono_array_addr_with_size (params, 8, D.23638);
        mono_gc_wbarrier_set_arrayref (params, __p, copy);
      }
    }
    <D.23653>:
    D.23635 = (long unsigned int) i;
    D.23636 = D.23635 * 8;
    D.23637 = pa + D.23636;
    D.23638 = (long unsigned int) i;
    D.23659 = mono_array_addr_with_size (params, 8, D.23638);
    D.23660 = MEM[(struct MonoObject * *)D.23659];
    D.23661 = mono_object_unbox (D.23660);
    *D.23637 = D.23661;
    <D.23629>:
    goto <D.20209>;
    <D.20210>:
    <D.20211>:
    <D.20212>:
    <D.20213>:
    <D.20214>:
    D.23641 = BIT_FIELD_REF <*t, 64, 64>;
    D.23642 = D.23641 & 8589934592;
    if (D.23642 != 0) goto <D.23662>; else goto <D.23663>;
    <D.23662>:
    D.23635 = (long unsigned int) i;
    D.23636 = D.23635 * 8;
    D.23637 = pa + D.23636;
    D.23638 = (long unsigned int) i;
    D.23664 = mono_array_addr_with_size (params, 8, D.23638);
    *D.23637 = D.23664;
    goto <D.23665>;
    <D.23663>:
    D.23635 = (long unsigned int) i;
    D.23636 = D.23635 * 8;
    D.23637 = pa + D.23636;
    D.23638 = (long unsigned int) i;
    D.23666 = mono_array_addr_with_size (params, 8, D.23638);
    D.23667 = MEM[(struct MonoObject * *)D.23666];
    *D.23637 = D.23667;
    <D.23665>:
    goto <D.20209>;
    <D.20215>:
    D.23641 = BIT_FIELD_REF <*t, 64, 64>;
    D.23642 = D.23641 & 8589934592;
    if (D.23642 != 0) goto <D.23668>; else goto <D.23669>;
    <D.23668>:
    D.23670 = t->data.generic_class;
    D.23671 = D.23670->container_class;
    t = &D.23671->this_arg;
    goto <D.23672>;
    <D.23669>:
    D.23670 = t->data.generic_class;
    D.23671 = D.23670->container_class;
    t = &D.23671->byval_arg;
    <D.23672>:
    goto again;
    <D.20216>:
    {
      struct MonoObject * arg;

      D.23638 = (long unsigned int) i;
      D.23673 = mono_array_addr_with_size (params, 8, D.23638);
      arg = MEM[(struct MonoObject * *)D.23673];
      if (arg == 0B) goto <D.23674>; else goto <D.23675>;
      <D.23674>:
      D.23635 = (long unsigned int) i;
      D.23636 = D.23635 * 8;
      D.23637 = pa + D.23636;
      *D.23637 = 0B;
      goto <D.23676>;
      <D.23675>:
      D.23677 = arg->vtable;
      D.23678 = D.23677->klass;
      D.23679 = mono_defaults.int_class;
      D.23680 = D.23678 != D.23679;
      D.23681 = (long int) D.23680;
      D.23682 = __builtin_expect (D.23681, 0);
      if (D.23682 != 0) goto <D.23683>; else goto <D.23684>;
      <D.23683>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 4211, "arg->vtable->klass == mono_defaults.int_class");
      <D.23684>:
      D.23635 = (long unsigned int) i;
      D.23636 = D.23635 * 8;
      D.23637 = pa + D.23636;
      D.23685 = MEM[(struct MonoIntPtr *)arg].m_value;
      *D.23637 = D.23685;
      <D.23676>:
      goto <D.20209>;
    }
    <D.20218>:
    D.23631 = sig->params[i];
    D.23686 = D.23631->type;
    D.23687 = (int) D.23686;
    monoeg_g_log (0B, 4, "type 0x%x not handled in mono_runtime_invoke_array", D.23687);
    <D.20219>:
    goto <D.20219>;
    <D.20209>:
  }
  i = i + 1;
  <D.20221>:
  D.23638 = (long unsigned int) i;
  D.23688 = mono_array_length (params);
  if (D.23638 < D.23688) goto <D.20220>; else goto <D.20222>;
  <D.20222>:
  <D.23623>:
  D.23690 = method->name;
  D.23691 = strcmp (D.23690, ".ctor");
  if (D.23691 == 0) goto <D.23692>; else goto <D.23689>;
  <D.23692>:
  D.23693 = method->klass;
  D.23694 = mono_defaults.string_class;
  if (D.23693 != D.23694) goto <D.23695>; else goto <D.23689>;
  <D.23695>:
  {
    void * o;

    o = obj;
    D.23693 = method->klass;
    D.23696 = mono_class_is_nullable (D.23693);
    if (D.23696 != 0) goto <D.23697>; else goto <D.23698>;
    <D.23697>:
    D.23699 = obj != 0B;
    D.23700 = (long int) D.23699;
    D.23701 = __builtin_expect (D.23700, 0);
    if (D.23701 != 0) goto <D.23702>; else goto <D.23703>;
    <D.23702>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 4227, "!obj");
    <D.23703>:
    if (params == 0B) goto <D.23704>; else goto <D.23705>;
    <D.23704>:
    D.23706 = 0B;
    return D.23706;
    <D.23705>:
    D.23707 = mono_domain_get ();
    D.23693 = method->klass;
    D.23708 = D.23693->cast_class;
    D.23709 = *pa;
    D.23706 = mono_value_box (D.23707, D.23708, D.23709);
    return D.23706;
    <D.23698>:
    if (obj == 0B) goto <D.23710>; else goto <D.23711>;
    <D.23710>:
    D.23712 = mono_domain_get ();
    D.23693 = method->klass;
    obj = mono_object_new (D.23712, D.23693);
    D.23713 = obj == 0B;
    D.23714 = (long int) D.23713;
    D.23715 = __builtin_expect (D.23714, 0);
    if (D.23715 != 0) goto <D.23716>; else goto <D.23717>;
    <D.23716>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 4237, "obj");
    <D.23717>:
    D.23718 = MEM[(struct MonoObject *)obj].vtable;
    D.23719 = D.23718->klass;
    D.23720 = mono_defaults.transparent_proxy_class;
    if (D.23719 == D.23720) goto <D.23721>; else goto <D.23722>;
    <D.23721>:
    D.23724 = method->slot;
    if (D.23724 != -1) goto <D.23725>; else goto <D.23726>;
    <D.23725>:
    D.23693 = method->klass;
    D.23727 = D.23693->vtable;
    D.23724 = method->slot;
    D.23728 = (long unsigned int) D.23724;
    D.23729 = D.23728 * 8;
    D.23730 = D.23727 + D.23729;
    iftmp.119 = *D.23730;
    goto <D.23731>;
    <D.23726>:
    iftmp.119 = method;
    <D.23731>:
    method = mono_marshal_get_remoting_invoke (iftmp.119);
    <D.23722>:
    D.23693 = method->klass;
    D.23732 = BIT_FIELD_REF <*D.23693, 64, 256>;
    D.23733 = D.23732 & 1152921504606846976;
    if (D.23733 != 0) goto <D.23734>; else goto <D.23735>;
    <D.23734>:
    o = mono_object_unbox (obj);
    goto <D.23736>;
    <D.23735>:
    o = obj;
    <D.23736>:
    goto <D.23737>;
    <D.23711>:
    D.23693 = method->klass;
    D.23732 = BIT_FIELD_REF <*D.23693, 64, 256>;
    D.23733 = D.23732 & 1152921504606846976;
    if (D.23733 != 0) goto <D.23738>; else goto <D.23739>;
    <D.23738>:
    D.23740 = mono_domain_get ();
    D.23693 = method->klass;
    obj = mono_value_box (D.23740, D.23693, obj);
    <D.23739>:
    <D.23737>:
    mono_runtime_invoke (method, o, pa, exc);
    D.23706 = obj;
    return D.23706;
  }
  <D.23689>:
  D.23693 = method->klass;
  D.23741 = mono_class_is_nullable (D.23693);
  if (D.23741 != 0) goto <D.23742>; else goto <D.23743>;
  <D.23742>:
  {
    struct MonoObject * nullable;

    D.23744 = mono_domain_get ();
    D.23693 = method->klass;
    nullable = mono_object_new (D.23744, D.23693);
    D.23745 = mono_object_unbox (nullable);
    D.23746 = mono_domain_get ();
    D.23693 = method->klass;
    D.23708 = D.23693->cast_class;
    D.23747 = mono_value_box (D.23746, D.23708, obj);
    D.23693 = method->klass;
    mono_nullable_init (D.23745, D.23747, D.23693);
    obj = mono_object_unbox (nullable);
  }
  <D.23743>:
  res = mono_runtime_invoke (method, obj, pa, exc);
  D.23748 = sig->ret;
  D.23749 = D.23748->type;
  if (D.23749 == 15) goto <D.23750>; else goto <D.23751>;
  <D.23750>:
  {
    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.120 = tmp_klass;
            if (tmp_klass.120 == 0B) goto <D.23753>; else goto <D.23754>;
            <D.23753>:
            if (0 != 0) goto <D.23755>; else goto <D.23756>;
            <D.23755>:
            monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 4277, "mono_defaults.corlib == mono_defaults.corlib");
            <D.23756>:
            D.23757 = mono_defaults.corlib;
            tmp_klass.121 = mono_class_from_name (D.23757, "System.Reflection", "Pointer");
            tmp_klass = tmp_klass.121;
            tmp_klass.120 = tmp_klass;
            D.23759 = tmp_klass.120 == 0B;
            D.23760 = (long int) D.23759;
            D.23761 = __builtin_expect (D.23760, 0);
            if (D.23761 != 0) goto <D.23762>; else goto <D.23763>;
            <D.23762>:
            monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 4277, "tmp_klass");
            <D.23763>:
            <D.23754>:
          }
          pointer_class.122 = tmp_klass;
        }
        pointer_class = pointer_class.122;
        box_method.123 = box_method;
        if (box_method.123 == 0B) goto <D.23765>; else goto <D.23766>;
        <D.23765>:
        box_method.124 = mono_class_get_method_from_name (pointer_class, "Box", -1);
        box_method = box_method.124;
        <D.23766>:
        D.23768 = res->vtable;
        D.23769 = D.23768->klass;
        D.23679 = mono_defaults.int_class;
        D.23770 = D.23769 != D.23679;
        D.23771 = (long int) D.23770;
        D.23772 = __builtin_expect (D.23771, 0);
        if (D.23772 != 0) goto <D.23773>; else goto <D.23774>;
        <D.23773>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 4281, "res->vtable->klass == mono_defaults.int_class");
        <D.23774>:
        D.23775 = MEM[(struct MonoIntPtr *)res].m_value;
        box_args[0] = D.23775;
        D.23776 = mono_domain_get ();
        D.23748 = sig->ret;
        D.23777 = mono_type_get_object (D.23776, D.23748);
        box_args[1] = D.23777;
        box_method.123 = box_method;
        res = mono_runtime_invoke (box_method.123, 0B, &box_args, &box_exc);
        box_exc.125 = box_exc;
        D.23779 = box_exc.125 != 0B;
        D.23780 = (long int) D.23779;
        D.23781 = __builtin_expect (D.23780, 0);
        if (D.23781 != 0) goto <D.23782>; else goto <D.23783>;
        <D.23782>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 4285, "!box_exc");
        <D.23783>:
      }
    finally
      {
        box_args = {CLOBBER};
        box_exc = {CLOBBER};
      }
  }
  <D.23751>:
  if (has_byref_nullables != 0) goto <D.23784>; else goto <D.23785>;
  <D.23784>:
  i = 0;
  goto <D.20234>;
  <D.20233>:
  {
    struct MonoType * t;

    t = sig->params[i];
    D.23786 = BIT_FIELD_REF <*t, 64, 64>;
    D.23787 = D.23786 & 280384055017472;
    if (D.23787 == 23098334117888) goto <D.23788>; else goto <D.23789>;
    <D.23788>:
    D.23790 = mono_class_from_mono_type (t);
    D.23791 = mono_class_is_nullable (D.23790);
    if (D.23791 != 0) goto <D.23792>; else goto <D.23793>;
    <D.23792>:
    {
      void * * __p;

      D.23638 = (long unsigned int) i;
      __p = mono_array_addr_with_size (params, 8, D.23638);
      D.23635 = (long unsigned int) i;
      D.23636 = D.23635 * 8;
      D.23637 = pa + D.23636;
      D.23794 = *D.23637;
      mono_gc_wbarrier_set_arrayref (params, __p, D.23794);
    }
    <D.23793>:
    <D.23789>:
  }
  i = i + 1;
  <D.20234>:
  D.23638 = (long unsigned int) i;
  D.23795 = mono_array_length (params);
  if (D.23638 < D.23795) goto <D.20233>; else goto <D.20235>;
  <D.20235>:
  <D.23785>:
  D.23706 = res;
  return D.23706;
}


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

  vtable = mono_class_vtable (domain, klass);
  if (vtable == 0B) goto <D.23797>; else goto <D.23798>;
  <D.23797>:
  D.23799 = 0B;
  return D.23799;
  <D.23798>:
  D.23799 = mono_object_new_specific (vtable);
  return D.23799;
}


__attribute__((visibility ("hidden")))
mono_object_new_pinned (struct MonoDomain * domain, struct MonoClass * klass)
{
  struct MonoObject * D.23803;
  int D.23804;
  long unsigned int D.23805;
  struct MonoVTable * vtable;

  vtable = mono_class_vtable (domain, klass);
  if (vtable == 0B) goto <D.23801>; else goto <D.23802>;
  <D.23801>:
  D.23803 = 0B;
  return D.23803;
  <D.23802>:
  D.23804 = mono_class_instance_size (klass);
  D.23805 = (long unsigned int) D.23804;
  D.23803 = mono_gc_alloc_pinned_obj (vtable, D.23805);
  return D.23803;
}


mono_object_new_specific (struct MonoVTable * vtable)
{
  long unsigned int D.23809;
  long unsigned int D.23810;
  struct MonoClass * D.23812;
  long unsigned int D.23813;
  long unsigned int D.23814;
  struct MonoDomain * D.23815;
  struct MonoImage * D.23818;
  long unsigned int D.23819;
  long unsigned int D.23820;
  _Bool D.23823;
  long int D.23824;
  long int D.23825;
  struct MonoDomain * D.23828;
  struct MonoType * D.23829;
  struct MonoReflectionType * D.23830;
  struct MonoObject * D.23833;
  struct MonoObject * o;

  D.23809 = BIT_FIELD_REF <*vtable, 64, 320>;
  D.23810 = D.23809 & 549755813888;
  if (D.23810 != 0) goto <D.23807>; else goto <D.23811>;
  <D.23811>:
  D.23812 = vtable->klass;
  D.23813 = BIT_FIELD_REF <*D.23812, 64, 256>;
  D.23814 = D.23813 & 8589934592;
  if (D.23814 != 0) goto <D.23807>; else goto <D.23808>;
  <D.23807>:
  {
    void * pa[1];
    struct MonoMethod * im;

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

          D.23818 = mono_defaults.corlib;
          klass = mono_class_from_name (D.23818, "System.Runtime.Remoting.Activation", "ActivationServices");
          D.23819 = BIT_FIELD_REF <*klass, 64, 256>;
          D.23820 = D.23819 & 9223372036854775808;
          if (D.23820 == 0) goto <D.23821>; else goto <D.23822>;
          <D.23821>:
          mono_class_init (klass);
          <D.23822>:
          im = mono_class_get_method_from_name (klass, "CreateProxyForType", 1);
          D.23823 = im == 0B;
          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", 4430, "im");
          <D.23827>:
          D.23815 = vtable->domain;
          D.23815->create_proxy_for_type_method = im;
        }
        <D.23817>:
        D.23828 = mono_domain_get ();
        D.23812 = vtable->klass;
        D.23829 = &D.23812->byval_arg;
        D.23830 = mono_type_get_object (D.23828, D.23829);
        pa[0] = D.23830;
        o = mono_runtime_invoke (im, 0B, &pa, 0B);
        if (o != 0B) goto <D.23831>; else goto <D.23832>;
        <D.23831>:
        D.23833 = o;
        return D.23833;
        <D.23832>:
      }
    finally
      {
        pa = {CLOBBER};
      }
  }
  <D.23808>:
  D.23833 = mono_object_new_alloc_specific (vtable);
  return D.23833;
}


mono_object_new_alloc_specific (struct MonoVTable * vtable)
{
  struct MonoClass * D.23837;
  long unsigned int D.23838;
  long unsigned int D.23839;
  void * D.23843;
  int D.23846;
  long unsigned int D.23847;
  long unsigned int D.23849;
  _Bool D.23850;
  long int D.23851;
  long int D.23852;
  int profile_allocs.126;
  _Bool D.23856;
  long int D.23857;
  long int D.23858;
  struct MonoObject * D.23861;
  struct MonoObject * o;

  D.23837 = vtable->klass;
  D.23838 = BIT_FIELD_REF <*D.23837, 64, 256>;
  D.23839 = D.23838 & 68719476736;
  if (D.23839 == 0) goto <D.23840>; else goto <D.23841>;
  <D.23840>:
  o = mono_object_new_ptrfree (vtable);
  goto <D.23842>;
  <D.23841>:
  D.23843 = vtable->gc_descr;
  if (D.23843 != 0B) goto <D.23844>; else goto <D.23845>;
  <D.23844>:
  D.23837 = vtable->klass;
  D.23846 = D.23837->instance_size;
  D.23847 = (long unsigned int) D.23846;
  o = mono_object_allocate_spec (D.23847, vtable);
  goto <D.23848>;
  <D.23845>:
  D.23837 = vtable->klass;
  D.23846 = D.23837->instance_size;
  D.23847 = (long unsigned int) D.23846;
  o = mono_object_allocate (D.23847, vtable);
  <D.23848>:
  <D.23842>:
  D.23837 = vtable->klass;
  D.23838 = BIT_FIELD_REF <*D.23837, 64, 256>;
  D.23849 = D.23838 & 4398046511104;
  D.23850 = D.23849 != 0;
  D.23851 = (long int) D.23850;
  D.23852 = __builtin_expect (D.23851, 0);
  if (D.23852 != 0) goto <D.23853>; else goto <D.23854>;
  <D.23853>:
  mono_object_register_finalizer (o);
  <D.23854>:
  profile_allocs.126 = profile_allocs;
  D.23856 = profile_allocs.126 != 0;
  D.23857 = (long int) D.23856;
  D.23858 = __builtin_expect (D.23857, 0);
  if (D.23858 != 0) goto <D.23859>; else goto <D.23860>;
  <D.23859>:
  D.23837 = vtable->klass;
  mono_profiler_allocation (o, D.23837);
  <D.23860>:
  D.23861 = o;
  return D.23861;
}


mono_object_allocate_spec (size_t size, struct MonoVTable * vtable)
{
  long unsigned int D.23863;
  long unsigned int D.23864;
  void * D.23865;
  void * o;

  o = mono_gc_alloc_obj (vtable, size);
  D.23863 = mono_stats.new_object_count;
  D.23864 = D.23863 + 1;
  mono_stats.new_object_count = D.23864;
  D.23865 = o;
  return D.23865;
}


mono_object_allocate (size_t size, struct MonoVTable * vtable)
{
  long unsigned int D.23867;
  long unsigned int D.23868;
  void * D.23869;
  struct MonoObject * o;

  D.23867 = mono_stats.new_object_count;
  D.23868 = D.23867 + 1;
  mono_stats.new_object_count = D.23868;
  o = mono_gc_alloc_obj (vtable, size);
  D.23869 = o;
  return D.23869;
}


mono_object_new_fast (struct MonoVTable * vtable)
{
  struct MonoClass * D.23871;
  int D.23872;
  long unsigned int D.23873;
  struct MonoObject * D.23874;
  struct MonoObject * o;

  D.23871 = vtable->klass;
  D.23872 = D.23871->instance_size;
  D.23873 = (long unsigned int) D.23872;
  o = mono_gc_alloc_obj (vtable, D.23873);
  D.23874 = o;
  return D.23874;
}


__attribute__((visibility ("hidden")))
mono_class_get_allocation_ftn (struct MonoVTable * vtable, gboolean for_box, gboolean * pass_size_in_words)
{
  <unnamed type> D.23876;
  unsigned int D.23877;
  struct MonoClass * D.23882;
  int D.23883;
  long unsigned int D.23885;
  long unsigned int D.23886;
  <unnamed type> D.23888;
  unsigned int D.23889;
  void * D.23890;
  long unsigned int D.23891;
  void * D.23896;

  *pass_size_in_words = 0;
  D.23876 = mono_profiler_get_events ();
  D.23877 = D.23876 & 128;
  if (D.23877 == 0) goto <D.23878>; else goto <D.23879>;
  <D.23878>:
  profile_allocs = 0;
  <D.23879>:
  D.23882 = vtable->klass;
  D.23883 = mono_class_has_finalizer (D.23882);
  if (D.23883 != 0) goto <D.23880>; else goto <D.23884>;
  <D.23884>:
  D.23882 = vtable->klass;
  D.23885 = BIT_FIELD_REF <*D.23882, 64, 256>;
  D.23886 = D.23885 & 2199023255552;
  if (D.23886 != 0) goto <D.23880>; else goto <D.23887>;
  <D.23887>:
  D.23888 = mono_profiler_get_events ();
  D.23889 = D.23888 & 128;
  if (D.23889 != 0) goto <D.23880>; else goto <D.23881>;
  <D.23880>:
  D.23890 = mono_object_new_specific;
  return D.23890;
  <D.23881>:
  D.23882 = vtable->klass;
  D.23885 = BIT_FIELD_REF <*D.23882, 64, 256>;
  D.23891 = D.23885 & 68719476736;
  if (D.23891 == 0) goto <D.23892>; else goto <D.23893>;
  <D.23892>:
  if (for_box != 0) goto <D.23894>; else goto <D.23895>;
  <D.23894>:
  D.23890 = mono_object_new_ptrfree_box;
  return D.23890;
  <D.23895>:
  D.23890 = mono_object_new_ptrfree;
  return D.23890;
  <D.23893>:
  D.23896 = vtable->gc_descr;
  if (D.23896 != 0B) goto <D.23897>; else goto <D.23898>;
  <D.23897>:
  D.23890 = mono_object_new_fast;
  return D.23890;
  <D.23898>:
  D.23890 = mono_object_new_specific;
  return D.23890;
}


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

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


mono_object_clone (struct MonoObject * obj)
{
  struct MonoVTable * D.23902;
  struct MonoClass * D.23903;
  unsigned char D.23904;
  struct MonoObject * D.23907;
  long unsigned int D.23908;
  long unsigned int D.23909;
  long unsigned int D.23910;
  void * D.23914;
  const void * D.23915;
  long unsigned int D.23916;
  long unsigned int D.23917;
  int profile_allocs.127;
  _Bool D.23919;
  long int D.23920;
  long int D.23921;
  long unsigned int D.23924;
  struct MonoObject * o;
  int size;

  D.23902 = obj->vtable;
  D.23903 = D.23902->klass;
  size = D.23903->instance_size;
  D.23902 = obj->vtable;
  D.23903 = D.23902->klass;
  D.23904 = D.23903->rank;
  if (D.23904 != 0) goto <D.23905>; else goto <D.23906>;
  <D.23905>:
  D.23907 = mono_array_clone (obj);
  return D.23907;
  <D.23906>:
  D.23908 = (long unsigned int) size;
  D.23902 = obj->vtable;
  o = mono_object_allocate (D.23908, D.23902);
  D.23902 = obj->vtable;
  D.23903 = D.23902->klass;
  D.23909 = BIT_FIELD_REF <*D.23903, 64, 256>;
  D.23910 = D.23909 & 68719476736;
  if (D.23910 != 0) goto <D.23911>; else goto <D.23912>;
  <D.23911>:
  mono_gc_wbarrier_object_copy (o, obj);
  goto <D.23913>;
  <D.23912>:
  {
    int size;

    D.23902 = obj->vtable;
    D.23903 = D.23902->klass;
    size = D.23903->instance_size;
    D.23914 = o + 16;
    D.23915 = obj + 16;
    D.23916 = (long unsigned int) size;
    D.23917 = D.23916 + 18446744073709551600;
    mono_gc_memmove_atomic (D.23914, D.23915, D.23917);
  }
  <D.23913>:
  profile_allocs.127 = profile_allocs;
  D.23919 = profile_allocs.127 != 0;
  D.23920 = (long int) D.23919;
  D.23921 = __builtin_expect (D.23920, 0);
  if (D.23921 != 0) goto <D.23922>; else goto <D.23923>;
  <D.23922>:
  D.23902 = obj->vtable;
  D.23903 = D.23902->klass;
  mono_profiler_allocation (o, D.23903);
  <D.23923>:
  D.23902 = obj->vtable;
  D.23903 = D.23902->klass;
  D.23909 = BIT_FIELD_REF <*D.23903, 64, 256>;
  D.23924 = D.23909 & 4398046511104;
  if (D.23924 != 0) goto <D.23925>; else goto <D.23926>;
  <D.23925>:
  mono_object_register_finalizer (o);
  <D.23926>:
  D.23907 = o;
  return D.23907;
}


__attribute__((visibility ("hidden")))
mono_array_full_copy (struct MonoArray * src, struct MonoArray * dest)
{
  struct MonoVTable * D.23928;
  struct MonoVTable * D.23929;
  struct MonoClass * D.23930;
  _Bool D.23931;
  long int D.23932;
  long int D.23933;
  long unsigned int D.23936;
  _Bool D.23937;
  long int D.23938;
  long int D.23939;
  int D.23942;
  long unsigned int D.23943;
  struct MonoClass * D.23944;
  long unsigned int D.23945;
  long unsigned int D.23946;
  long unsigned int D.23949;
  double[0:] * D.23952;
  long unsigned int D.23953;
  int D.23954;
  double[0:] * D.23956;
  long unsigned int D.23958;
  int D.23959;
  uintptr_t size;
  struct MonoClass * klass;

  D.23928 = src->obj.vtable;
  klass = D.23928->klass;
  D.23929 = dest->obj.vtable;
  D.23930 = D.23929->klass;
  D.23931 = D.23930 != klass;
  D.23932 = (long int) D.23931;
  D.23933 = __builtin_expect (D.23932, 0);
  if (D.23933 != 0) goto <D.23934>; else goto <D.23935>;
  <D.23934>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 4619, "klass == dest->obj.vtable->klass");
  <D.23935>:
  size = mono_array_length (src);
  D.23936 = mono_array_length (dest);
  D.23937 = D.23936 != size;
  D.23938 = (long int) D.23937;
  D.23939 = __builtin_expect (D.23938, 0);
  if (D.23939 != 0) goto <D.23940>; else goto <D.23941>;
  <D.23940>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 4622, "size == mono_array_length (dest)");
  <D.23941>:
  D.23942 = mono_array_element_size (klass);
  D.23943 = (long unsigned int) D.23942;
  size = D.23943 * size;
  D.23944 = klass->element_class;
  D.23945 = BIT_FIELD_REF <*D.23944, 64, 256>;
  D.23946 = D.23945 & 1152921504606846976;
  if (D.23946 != 0) goto <D.23947>; else goto <D.23948>;
  <D.23947>:
  D.23944 = klass->element_class;
  D.23945 = BIT_FIELD_REF <*D.23944, 64, 256>;
  D.23949 = D.23945 & 68719476736;
  if (D.23949 != 0) goto <D.23950>; else goto <D.23951>;
  <D.23950>:
  D.23952 = &src->vector;
  D.23953 = mono_array_length (src);
  D.23954 = (int) D.23953;
  mono_value_copy_array (dest, 0, D.23952, D.23954);
  goto <D.23955>;
  <D.23951>:
  D.23956 = &dest->vector;
  D.23952 = &src->vector;
  mono_gc_memmove_atomic (D.23956, D.23952, size);
  <D.23955>:
  goto <D.23957>;
  <D.23948>:
  {
    void * * __p;
    void * * __s;

    __p = mono_array_addr_with_size (dest, 8, 0);
    __s = mono_array_addr_with_size (src, 8, 0);
    D.23958 = mono_array_length (src);
    D.23959 = (int) D.23958;
    mono_gc_wbarrier_arrayref_copy (__p, __s, D.23959);
  }
  <D.23957>:
}


__attribute__((visibility ("hidden")))
mono_array_clone_in_domain (struct MonoDomain * domain, struct MonoArray * array)
{
  struct MonoVTable * D.23960;
  struct MonoArrayBounds * D.23961;
  long unsigned int size.128;
  int D.23965;
  long unsigned int D.23966;
  long unsigned int size.129;
  long unsigned int size.130;
  struct MonoClass * D.23969;
  long unsigned int D.23970;
  long unsigned int D.23971;
  long unsigned int D.23974;
  double[0:] * D.23977;
  long unsigned int D.23978;
  int D.23979;
  double[0:] * D.23981;
  long unsigned int D.23983;
  int D.23984;
  struct MonoArray * D.23985;
  unsigned char D.23986;
  long unsigned int D.23987;
  long unsigned int D.23988;
  int D.23989;
  long unsigned int size.131;
  long unsigned int D.23991;
  uintptr_t * D.23992;
  struct MonoArrayBounds * D.23993;
  unsigned int D.23994;
  long unsigned int D.23995;
  long unsigned int size.132;
  long unsigned int D.23997;
  long unsigned int D.23998;
  long unsigned int D.23999;
  uintptr_t * D.24000;
  int D.24001;
  long unsigned int D.24002;
  long unsigned int D.24003;
  intptr_t * D.24004;
  long unsigned int D.24009;
  int D.24010;
  long unsigned int D.24013;
  int D.24014;
  struct MonoArray * o;
  uintptr_t size;
  uintptr_t i;
  uintptr_t * sizes;
  struct MonoClass * klass;

  try
    {
      D.23960 = array->obj.vtable;
      klass = D.23960->klass;
      D.23961 = array->bounds;
      if (D.23961 == 0B) goto <D.23962>; else goto <D.23963>;
      <D.23962>:
      size.128 = mono_array_length (array);
      size = size.128;
      o = mono_array_new_full (domain, klass, &size, 0B);
      D.23965 = mono_array_element_size (klass);
      D.23966 = (long unsigned int) D.23965;
      size.129 = size;
      size.130 = D.23966 * size.129;
      size = size.130;
      D.23969 = klass->element_class;
      D.23970 = BIT_FIELD_REF <*D.23969, 64, 256>;
      D.23971 = D.23970 & 1152921504606846976;
      if (D.23971 != 0) goto <D.23972>; else goto <D.23973>;
      <D.23972>:
      D.23969 = klass->element_class;
      D.23970 = BIT_FIELD_REF <*D.23969, 64, 256>;
      D.23974 = D.23970 & 68719476736;
      if (D.23974 != 0) goto <D.23975>; else goto <D.23976>;
      <D.23975>:
      D.23977 = &array->vector;
      D.23978 = mono_array_length (array);
      D.23979 = (int) D.23978;
      mono_value_copy_array (o, 0, D.23977, D.23979);
      goto <D.23980>;
      <D.23976>:
      D.23981 = &o->vector;
      D.23977 = &array->vector;
      size.129 = size;
      mono_gc_memmove_atomic (D.23981, D.23977, size.129);
      <D.23980>:
      goto <D.23982>;
      <D.23973>:
      {
        void * * __p;
        void * * __s;

        __p = mono_array_addr_with_size (o, 8, 0);
        __s = mono_array_addr_with_size (array, 8, 0);
        D.23983 = mono_array_length (array);
        D.23984 = (int) D.23983;
        mono_gc_wbarrier_arrayref_copy (__p, __s, D.23984);
      }
      <D.23982>:
      D.23985 = o;
      return D.23985;
      <D.23963>:
      D.23986 = klass->rank;
      D.23987 = (long unsigned int) D.23986;
      D.23988 = D.23987 * 16;
      sizes = __builtin_alloca (D.23988);
      D.23989 = mono_array_element_size (klass);
      size.131 = (long unsigned int) D.23989;
      size = size.131;
      i = 0;
      goto <D.20324>;
      <D.20323>:
      D.23991 = i * 8;
      D.23992 = sizes + D.23991;
      D.23961 = array->bounds;
      D.23991 = i * 8;
      D.23993 = D.23961 + D.23991;
      D.23994 = D.23993->length;
      D.23995 = (long unsigned int) D.23994;
      *D.23992 = D.23995;
      D.23961 = array->bounds;
      D.23991 = i * 8;
      D.23993 = D.23961 + D.23991;
      D.23994 = D.23993->length;
      D.23995 = (long unsigned int) D.23994;
      size.129 = size;
      size.132 = D.23995 * size.129;
      size = size.132;
      D.23986 = klass->rank;
      D.23997 = (long unsigned int) D.23986;
      D.23998 = D.23997 + i;
      D.23999 = D.23998 * 8;
      D.24000 = sizes + D.23999;
      D.23961 = array->bounds;
      D.23991 = i * 8;
      D.23993 = D.23961 + D.23991;
      D.24001 = D.23993->lower_bound;
      D.24002 = (long unsigned int) D.24001;
      *D.24000 = D.24002;
      i = i + 1;
      <D.20324>:
      D.23986 = klass->rank;
      D.23997 = (long unsigned int) D.23986;
      if (D.23997 > i) goto <D.20323>; else goto <D.20325>;
      <D.20325>:
      D.23986 = klass->rank;
      D.23987 = (long unsigned int) D.23986;
      D.24003 = D.23987 * 8;
      D.24004 = sizes + D.24003;
      o = mono_array_new_full (domain, klass, sizes, D.24004);
      D.23969 = klass->element_class;
      D.23970 = BIT_FIELD_REF <*D.23969, 64, 256>;
      D.23971 = D.23970 & 1152921504606846976;
      if (D.23971 != 0) goto <D.24005>; else goto <D.24006>;
      <D.24005>:
      D.23969 = klass->element_class;
      D.23970 = BIT_FIELD_REF <*D.23969, 64, 256>;
      D.23974 = D.23970 & 68719476736;
      if (D.23974 != 0) goto <D.24007>; else goto <D.24008>;
      <D.24007>:
      D.23977 = &array->vector;
      D.24009 = mono_array_length (array);
      D.24010 = (int) D.24009;
      mono_value_copy_array (o, 0, D.23977, D.24010);
      goto <D.24011>;
      <D.24008>:
      D.23981 = &o->vector;
      D.23977 = &array->vector;
      size.129 = size;
      mono_gc_memmove_atomic (D.23981, D.23977, size.129);
      <D.24011>:
      goto <D.24012>;
      <D.24006>:
      {
        void * * __p;
        void * * __s;

        __p = mono_array_addr_with_size (o, 8, 0);
        __s = mono_array_addr_with_size (array, 8, 0);
        D.24013 = mono_array_length (array);
        D.24014 = (int) D.24013;
        mono_gc_wbarrier_arrayref_copy (__p, __s, D.24014);
      }
      <D.24012>:
      D.23985 = o;
      return D.23985;
    }
  finally
    {
      size = {CLOBBER};
    }
}


mono_array_clone (struct MonoArray * array)
{
  struct MonoArray * D.24017;
  struct MonoVTable * D.24018;
  struct MonoDomain * D.24019;

  D.24018 = MEM[(struct MonoObject *)array].vtable;
  D.24019 = D.24018->domain;
  D.24017 = mono_array_clone_in_domain (D.24019, array);
  return D.24017;
}


__attribute__((visibility ("hidden")))
mono_array_calc_byte_len (struct MonoClass * class, uintptr_t len, uintptr_t * res)
{
  int D.24021;
  int iftmp.133;
  unsigned int D.24025;
  unsigned int D.24027;
  unsigned int D.24029;
  _Bool D.24031;
  long int D.24032;
  long int D.24033;
  gboolean D.24036;
  _Bool D.24037;
  long int D.24038;
  long int D.24039;
  uintptr_t byte_len;

  D.24021 = mono_array_element_size (class);
  byte_len = (uintptr_t) D.24021;
  D.24025 = (unsigned int) byte_len;
  if (D.24025 != 0) goto <D.24026>; else goto <D.24023>;
  <D.24026>:
  D.24027 = (unsigned int) len;
  if (D.24027 != 0) goto <D.24028>; else goto <D.24023>;
  <D.24028>:
  D.24027 = (unsigned int) len;
  D.24025 = (unsigned int) byte_len;
  D.24029 = 4294967295 / D.24025;
  if (D.24027 > D.24029) goto <D.24030>; else goto <D.24023>;
  <D.24030>:
  iftmp.133 = 1;
  goto <D.24024>;
  <D.24023>:
  iftmp.133 = 0;
  <D.24024>:
  D.24031 = iftmp.133 != 0;
  D.24032 = (long int) D.24031;
  D.24033 = __builtin_expect (D.24032, 0);
  if (D.24033 != 0) goto <D.24034>; else goto <D.24035>;
  <D.24034>:
  D.24036 = 0;
  return D.24036;
  <D.24035>:
  byte_len = byte_len * len;
  D.24025 = (unsigned int) byte_len;
  D.24037 = D.24025 > 4294967263;
  D.24038 = (long int) D.24037;
  D.24039 = __builtin_expect (D.24038, 0);
  if (D.24039 != 0) goto <D.24040>; else goto <D.24041>;
  <D.24040>:
  D.24036 = 0;
  return D.24036;
  <D.24041>:
  byte_len = byte_len + 32;
  *res = byte_len;
  D.24036 = 1;
  return D.24036;
}


mono_array_new_full (struct MonoDomain * domain, struct MonoClass * array_class, uintptr_t * lengths, intptr_t * lower_bounds)
{
  long unsigned int D.24043;
  long unsigned int D.24044;
  unsigned char D.24049;
  unsigned char D.24051;
  long int D.24054;
  long unsigned int D.24057;
  long unsigned int D.24058;
  long unsigned int D.24059;
  uintptr_t * D.24060;
  long unsigned int D.24061;
  int iftmp.134;
  unsigned int D.24067;
  unsigned int D.24069;
  unsigned int D.24071;
  _Bool D.24073;
  long int D.24074;
  long int D.24075;
  int D.24078;
  int D.24079;
  long unsigned int byte_len.135;
  unsigned int D.24085;
  _Bool D.24086;
  long int D.24087;
  long int D.24088;
  long unsigned int D.24091;
  long unsigned int byte_len.136;
  unsigned int D.24093;
  unsigned int D.24094;
  _Bool D.24095;
  long int D.24096;
  long int D.24097;
  long unsigned int byte_len.137;
  long unsigned int D.24104;
  long unsigned int D.24105;
  struct MonoArrayBounds * D.24108;
  unsigned int D.24109;
  intptr_t * D.24112;
  long int D.24113;
  int D.24114;
  int profile_allocs.138;
  _Bool D.24116;
  long int D.24117;
  long int D.24118;
  struct MonoArray * D.24121;
  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.24043 = BIT_FIELD_REF <*array_class, 64, 256>;
      D.24044 = D.24043 & 9223372036854775808;
      if (D.24044 == 0) goto <D.24045>; else goto <D.24046>;
      <D.24045>:
      mono_class_init (array_class);
      <D.24046>:
      len = 1;
      D.24049 = array_class->rank;
      if (D.24049 == 1) goto <D.24050>; else goto <D.24047>;
      <D.24050>:
      D.24051 = array_class->byval_arg.type;
      if (D.24051 == 29) goto <D.24048>; else goto <D.24052>;
      <D.24052>:
      if (lower_bounds != 0B) goto <D.24053>; else goto <D.24047>;
      <D.24053>:
      D.24054 = *lower_bounds;
      if (D.24054 == 0) goto <D.24048>; else goto <D.24047>;
      <D.24048>:
      len = *lengths;
      if (len > 2147483647) goto <D.24055>; else goto <D.24056>;
      <D.24055>:
      arith_overflow ();
      <D.24056>:
      bounds_size = 0;
      goto <D.20353>;
      <D.24047>:
      D.24049 = array_class->rank;
      D.24057 = (long unsigned int) D.24049;
      bounds_size = D.24057 * 8;
      i = 0;
      goto <D.20352>;
      <D.20351>:
      D.24058 = (long unsigned int) i;
      D.24059 = D.24058 * 8;
      D.24060 = lengths + D.24059;
      D.24061 = *D.24060;
      if (D.24061 > 2147483647) goto <D.24062>; else goto <D.24063>;
      <D.24062>:
      arith_overflow ();
      <D.24063>:
      D.24067 = (unsigned int) len;
      if (D.24067 != 0) goto <D.24068>; else goto <D.24065>;
      <D.24068>:
      D.24058 = (long unsigned int) i;
      D.24059 = D.24058 * 8;
      D.24060 = lengths + D.24059;
      D.24061 = *D.24060;
      D.24069 = (unsigned int) D.24061;
      if (D.24069 != 0) goto <D.24070>; else goto <D.24065>;
      <D.24070>:
      D.24058 = (long unsigned int) i;
      D.24059 = D.24058 * 8;
      D.24060 = lengths + D.24059;
      D.24061 = *D.24060;
      D.24069 = (unsigned int) D.24061;
      D.24067 = (unsigned int) len;
      D.24071 = 4294967295 / D.24067;
      if (D.24069 > D.24071) goto <D.24072>; else goto <D.24065>;
      <D.24072>:
      iftmp.134 = 1;
      goto <D.24066>;
      <D.24065>:
      iftmp.134 = 0;
      <D.24066>:
      D.24073 = iftmp.134 != 0;
      D.24074 = (long int) D.24073;
      D.24075 = __builtin_expect (D.24074, 0);
      if (D.24075 != 0) goto <D.24076>; else goto <D.24077>;
      <D.24076>:
      mono_gc_out_of_memory (4294967295);
      <D.24077>:
      D.24058 = (long unsigned int) i;
      D.24059 = D.24058 * 8;
      D.24060 = lengths + D.24059;
      D.24061 = *D.24060;
      len = D.24061 * len;
      i = i + 1;
      <D.20352>:
      D.24049 = array_class->rank;
      D.24078 = (int) D.24049;
      if (D.24078 > i) goto <D.20351>; else goto <D.20353>;
      <D.20353>:
      D.24079 = mono_array_calc_byte_len (array_class, len, &byte_len);
      if (D.24079 == 0) goto <D.24080>; else goto <D.24081>;
      <D.24080>:
      mono_gc_out_of_memory (4294967295);
      <D.24081>:
      if (bounds_size != 0) goto <D.24082>; else goto <D.24083>;
      <D.24082>:
      byte_len.135 = byte_len;
      D.24085 = (unsigned int) byte_len.135;
      D.24086 = D.24085 > 4294967292;
      D.24087 = (long int) D.24086;
      D.24088 = __builtin_expect (D.24087, 0);
      if (D.24088 != 0) goto <D.24089>; else goto <D.24090>;
      <D.24089>:
      mono_gc_out_of_memory (4294967295);
      <D.24090>:
      byte_len.135 = byte_len;
      D.24091 = byte_len.135 + 3;
      byte_len.136 = D.24091 & 18446744073709551612;
      byte_len = byte_len.136;
      D.24093 = (unsigned int) bounds_size;
      D.24094 = ~D.24093;
      byte_len.135 = byte_len;
      D.24085 = (unsigned int) byte_len.135;
      D.24095 = D.24094 < D.24085;
      D.24096 = (long int) D.24095;
      D.24097 = __builtin_expect (D.24096, 0);
      if (D.24097 != 0) goto <D.24098>; else goto <D.24099>;
      <D.24098>:
      mono_gc_out_of_memory (4294967295);
      <D.24099>:
      byte_len.135 = byte_len;
      byte_len.137 = byte_len.135 + bounds_size;
      byte_len = byte_len.137;
      <D.24083>:
      vtable = mono_class_vtable_full (domain, array_class, 1);
      if (bounds_size != 0) goto <D.24101>; else goto <D.24102>;
      <D.24101>:
      byte_len.135 = byte_len;
      o = mono_gc_alloc_array (vtable, byte_len.135, len, bounds_size);
      goto <D.24103>;
      <D.24102>:
      byte_len.135 = byte_len;
      o = mono_gc_alloc_vector (vtable, byte_len.135, len);
      <D.24103>:
      array = o;
      D.24104 = mono_stats.new_object_count;
      D.24105 = D.24104 + 1;
      mono_stats.new_object_count = D.24105;
      bounds = array->bounds;
      if (bounds_size != 0) goto <D.24106>; else goto <D.24107>;
      <D.24106>:
      i = 0;
      goto <D.20355>;
      <D.20354>:
      D.24058 = (long unsigned int) i;
      D.24059 = D.24058 * 8;
      D.24108 = bounds + D.24059;
      D.24058 = (long unsigned int) i;
      D.24059 = D.24058 * 8;
      D.24060 = lengths + D.24059;
      D.24061 = *D.24060;
      D.24109 = (unsigned int) D.24061;
      D.24108->length = D.24109;
      if (lower_bounds != 0B) goto <D.24110>; else goto <D.24111>;
      <D.24110>:
      D.24058 = (long unsigned int) i;
      D.24059 = D.24058 * 8;
      D.24108 = bounds + D.24059;
      D.24058 = (long unsigned int) i;
      D.24059 = D.24058 * 8;
      D.24112 = lower_bounds + D.24059;
      D.24113 = *D.24112;
      D.24114 = (int) D.24113;
      D.24108->lower_bound = D.24114;
      <D.24111>:
      i = i + 1;
      <D.20355>:
      D.24049 = array_class->rank;
      D.24078 = (int) D.24049;
      if (D.24078 > i) goto <D.20354>; else goto <D.20356>;
      <D.20356>:
      <D.24107>:
      profile_allocs.138 = profile_allocs;
      D.24116 = profile_allocs.138 != 0;
      D.24117 = (long int) D.24116;
      D.24118 = __builtin_expect (D.24117, 0);
      if (D.24118 != 0) goto <D.24119>; else goto <D.24120>;
      <D.24119>:
      mono_profiler_allocation (o, array_class);
      <D.24120>:
      D.24121 = array;
      return D.24121;
    }
  finally
    {
      byte_len = {CLOBBER};
    }
}


arith_overflow ()
{
  struct MonoException * D.24124;

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


mono_array_new (struct MonoDomain * domain, struct MonoClass * eclass, uintptr_t n)
{
  _Bool D.24125;
  long int D.24126;
  long int D.24127;
  struct MonoArray * D.24130;
  struct MonoVTable * D.24131;
  struct MonoClass * ac;

  ac = mono_array_class_get (eclass, 1);
  D.24125 = ac == 0B;
  D.24126 = (long int) D.24125;
  D.24127 = __builtin_expect (D.24126, 0);
  if (D.24127 != 0) goto <D.24128>; else goto <D.24129>;
  <D.24128>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 4869, "ac");
  <D.24129>:
  D.24131 = mono_class_vtable_full (domain, ac, 1);
  D.24130 = mono_array_new_specific (D.24131, n);
  return D.24130;
}


mono_array_new_specific (struct MonoVTable * vtable, uintptr_t n)
{
  _Bool D.24133;
  long int D.24134;
  long int D.24135;
  struct MonoArray * D.24138;
  struct MonoClass * D.24139;
  int D.24140;
  long unsigned int byte_len.139;
  long unsigned int D.24144;
  long unsigned int D.24145;
  int profile_allocs.140;
  _Bool D.24147;
  long int D.24148;
  long int D.24149;
  struct MonoObject * o;
  struct MonoArray * ao;
  uintptr_t byte_len;

  try
    {
      D.24133 = n > 2147483647;
      D.24134 = (long int) D.24133;
      D.24135 = __builtin_expect (D.24134, 0);
      if (D.24135 != 0) goto <D.24136>; else goto <D.24137>;
      <D.24136>:
      arith_overflow ();
      D.24138 = 0B;
      return D.24138;
      <D.24137>:
      D.24139 = vtable->klass;
      D.24140 = mono_array_calc_byte_len (D.24139, n, &byte_len);
      if (D.24140 == 0) goto <D.24141>; else goto <D.24142>;
      <D.24141>:
      mono_gc_out_of_memory (4294967295);
      D.24138 = 0B;
      return D.24138;
      <D.24142>:
      byte_len.139 = byte_len;
      o = mono_gc_alloc_vector (vtable, byte_len.139, n);
      ao = o;
      D.24144 = mono_stats.new_object_count;
      D.24145 = D.24144 + 1;
      mono_stats.new_object_count = D.24145;
      profile_allocs.140 = profile_allocs;
      D.24147 = profile_allocs.140 != 0;
      D.24148 = (long int) D.24147;
      D.24149 = __builtin_expect (D.24148, 0);
      if (D.24149 != 0) goto <D.24150>; else goto <D.24151>;
      <D.24150>:
      D.24139 = vtable->klass;
      mono_profiler_allocation (o, D.24139);
      <D.24151>:
      D.24138 = ao;
      return D.24138;
    }
  finally
    {
      byte_len = {CLOBBER};
    }
}


mono_string_new_utf16 (struct MonoDomain * domain, const guint16 * text, gint32 len)
{
  _Bool D.24154;
  long int D.24155;
  long int D.24156;
  mono_unichar2 * D.24159;
  int D.24160;
  long unsigned int D.24161;
  struct MonoString * D.24162;
  struct MonoString * s;

  s = mono_string_new_size (domain, len);
  D.24154 = s == 0B;
  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", 4941, "s != NULL");
  <D.24158>:
  D.24159 = mono_string_chars (s);
  D.24160 = len * 2;
  D.24161 = (long unsigned int) D.24160;
  memcpy (D.24159, text, D.24161);
  D.24162 = s;
  return D.24162;
}


mono_string_new_size (struct MonoDomain * domain, gint32 len)
{
  int D.24164;
  int D.24165;
  long unsigned int D.24166;
  long unsigned int D.24167;
  struct MonoClass * D.24170;
  _Bool D.24171;
  long int D.24172;
  long int D.24173;
  int profile_allocs.141;
  _Bool D.24177;
  long int D.24178;
  long int D.24179;
  struct MonoString * D.24182;
  struct MonoString * s;
  struct MonoVTable * vtable;
  size_t size;

  D.24164 = len + 1;
  D.24165 = D.24164 * 2;
  D.24166 = (long unsigned int) D.24165;
  size = D.24166 + 24;
  D.24167 = (long unsigned int) len;
  if (D.24167 > size) goto <D.24168>; else goto <D.24169>;
  <D.24168>:
  mono_gc_out_of_memory (18446744073709551615);
  <D.24169>:
  D.24170 = mono_defaults.string_class;
  vtable = mono_class_vtable (domain, D.24170);
  D.24171 = vtable == 0B;
  D.24172 = (long int) D.24171;
  D.24173 = __builtin_expect (D.24172, 0);
  if (D.24173 != 0) goto <D.24174>; else goto <D.24175>;
  <D.24174>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 4967, "vtable");
  <D.24175>:
  s = mono_gc_alloc_string (vtable, size, len);
  profile_allocs.141 = profile_allocs;
  D.24177 = profile_allocs.141 != 0;
  D.24178 = (long int) D.24177;
  D.24179 = __builtin_expect (D.24178, 0);
  if (D.24179 != 0) goto <D.24180>; else goto <D.24181>;
  <D.24180>:
  D.24170 = mono_defaults.string_class;
  mono_profiler_allocation (s, D.24170);
  <D.24181>:
  D.24182 = s;
  return D.24182;
}


mono_string_new_len (struct MonoDomain * domain, const char * text, guint length)
{
  long int D.24184;
  struct GError * error.142;
  long int items_written.143;
  int D.24189;
  struct MonoString * D.24191;
  struct GError * error;
  struct MonoString * o;
  guint16 * ut;
  glong items_written;

  try
    {
      error = 0B;
      o = 0B;
      D.24184 = (long int) length;
      ut = eg_utf8_to_utf16_with_nuls (text, D.24184, 0B, &items_written, &error);
      error.142 = error;
      if (error.142 == 0B) goto <D.24186>; else goto <D.24187>;
      <D.24186>:
      items_written.143 = items_written;
      D.24189 = (int) items_written.143;
      o = mono_string_new_utf16 (domain, ut, D.24189);
      goto <D.24190>;
      <D.24187>:
      error.142 = error;
      monoeg_g_error_free (error.142);
      <D.24190>:
      monoeg_g_free (ut);
      D.24191 = o;
      return D.24191;
    }
  finally
    {
      error = {CLOBBER};
      items_written = {CLOBBER};
    }
}


mono_string_new (struct MonoDomain * domain, const char * text)
{
  long unsigned int D.24194;
  long int D.24195;
  struct GError * error.144;
  long int items_written.145;
  int D.24200;
  struct MonoString * D.24202;
  struct GError * error;
  struct MonoString * o;
  guint16 * ut;
  glong items_written;
  int l;

  try
    {
      error = 0B;
      o = 0B;
      D.24194 = __strlen_g (text);
      l = (int) D.24194;
      D.24195 = (long int) l;
      ut = monoeg_g_utf8_to_utf16 (text, D.24195, 0B, &items_written, &error);
      error.144 = error;
      if (error.144 == 0B) goto <D.24197>; else goto <D.24198>;
      <D.24197>:
      items_written.145 = items_written;
      D.24200 = (int) items_written.145;
      o = mono_string_new_utf16 (domain, ut, D.24200);
      goto <D.24201>;
      <D.24198>:
      error.144 = error;
      monoeg_g_error_free (error.144);
      <D.24201>:
      monoeg_g_free (ut);
      D.24202 = o;
      return D.24202;
    }
  finally
    {
      error = {CLOBBER};
      items_written = {CLOBBER};
    }
}


__attribute__((__gnu_inline__))
__strlen_g (const char * __str)
{
  size_t D.24205;
  long int __ptr.146;
  long int __str.147;
  long int D.24208;
  char * __ptr;
  char * __tmp;

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


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

  domain = mono_domain_get ();
  if (text != 0B) goto <D.24210>; else goto <D.24211>;
  <D.24210>:
  D.24212 = mono_string_new (domain, text);
  return D.24212;
  <D.24211>:
  D.24212 = 0B;
  return D.24212;
}


mono_value_box (struct MonoDomain * domain, struct MonoClass * class, void * value)
{
  long unsigned int D.24214;
  long unsigned int D.24215;
  _Bool D.24216;
  long int D.24217;
  long int D.24218;
  int D.24221;
  struct MonoObject * D.24224;
  int profile_allocs.148;
  _Bool D.24228;
  long int D.24229;
  long int D.24230;
  unsigned int size.149;
  unsigned int D.24234;
  int D.24235;
  _Bool D.24236;
  long int D.24237;
  long int D.24238;
  void * D.24241;
  long unsigned int D.24242;
  struct MonoObject * res;
  int size;
  struct MonoVTable * vtable;

  D.24214 = BIT_FIELD_REF <*class, 64, 256>;
  D.24215 = D.24214 & 1152921504606846976;
  D.24216 = D.24215 == 0;
  D.24217 = (long int) D.24216;
  D.24218 = __builtin_expect (D.24217, 0);
  if (D.24218 != 0) goto <D.24219>; else goto <D.24220>;
  <D.24219>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 5092, "class->valuetype");
  <D.24220>:
  D.24221 = mono_class_is_nullable (class);
  if (D.24221 != 0) goto <D.24222>; else goto <D.24223>;
  <D.24222>:
  D.24224 = mono_nullable_box (value, class);
  return D.24224;
  <D.24223>:
  vtable = mono_class_vtable (domain, class);
  if (vtable == 0B) goto <D.24225>; else goto <D.24226>;
  <D.24225>:
  D.24224 = 0B;
  return D.24224;
  <D.24226>:
  size = mono_class_instance_size (class);
  res = mono_object_new_alloc_specific (vtable);
  profile_allocs.148 = profile_allocs;
  D.24228 = profile_allocs.148 != 0;
  D.24229 = (long int) D.24228;
  D.24230 = __builtin_expect (D.24229, 0);
  if (D.24230 != 0) goto <D.24231>; else goto <D.24232>;
  <D.24231>:
  mono_profiler_allocation (res, class);
  <D.24232>:
  size.149 = (unsigned int) size;
  D.24234 = size.149 + 4294967280;
  size = (int) D.24234;
  D.24235 = mono_class_value_size (class, 0B);
  D.24236 = D.24235 != size;
  D.24237 = (long int) D.24236;
  D.24238 = __builtin_expect (D.24237, 0);
  if (D.24238 != 0) goto <D.24239>; else goto <D.24240>;
  <D.24239>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 5107, "size == mono_class_value_size (class, NULL)");
  <D.24240>:
  D.24241 = res + 16;
  mono_gc_wbarrier_value_copy (D.24241, value, 1, class);
  D.24214 = BIT_FIELD_REF <*class, 64, 256>;
  D.24242 = D.24214 & 4398046511104;
  if (D.24242 != 0) goto <D.24243>; else goto <D.24244>;
  <D.24243>:
  mono_object_register_finalizer (res);
  <D.24244>:
  D.24224 = res;
  return D.24224;
}


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.24246;
  struct MonoClass * D.24247;
  double[0:] * D.24248;
  int D.24249;
  sizetype D.24250;
  struct MonoVTable * D.24251;
  struct MonoClass * D.24252;
  struct MonoClass * D.24253;
  int D.24254;
  _Bool D.24255;
  long int D.24256;
  long int D.24257;
  int size;
  char * d;

  D.24246 = dest->obj.vtable;
  D.24247 = D.24246->klass;
  size = mono_array_element_size (D.24247);
  D.24248 = &dest->vector;
  D.24249 = size * dest_idx;
  D.24250 = (sizetype) D.24249;
  d = D.24248 + D.24250;
  D.24251 = MEM[(struct MonoObject *)dest].vtable;
  D.24252 = D.24251->klass;
  D.24253 = D.24252->element_class;
  D.24254 = mono_class_value_size (D.24253, 0B);
  D.24255 = D.24254 != size;
  D.24256 = (long int) D.24255;
  D.24257 = __builtin_expect (D.24256, 0);
  if (D.24257 != 0) goto <D.24258>; else goto <D.24259>;
  <D.24258>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 5167, "size == mono_class_value_size (mono_object_class (dest)->element_class, NULL)");
  <D.24259>:
  D.24251 = MEM[(struct MonoObject *)dest].vtable;
  D.24252 = D.24251->klass;
  D.24253 = D.24252->element_class;
  mono_gc_wbarrier_value_copy (d, src, count, D.24253);
}


mono_object_get_domain (struct MonoObject * obj)
{
  struct MonoDomain * D.24260;
  struct MonoVTable * D.24261;

  D.24261 = obj->vtable;
  D.24260 = D.24261->domain;
  return D.24260;
}


mono_object_get_class (struct MonoObject * obj)
{
  struct MonoClass * D.24263;
  struct MonoVTable * D.24264;

  D.24264 = obj->vtable;
  D.24263 = D.24264->klass;
  return D.24263;
}


mono_object_get_size (struct MonoObject * o)
{
  struct MonoVTable * D.24266;
  struct MonoClass * D.24267;
  unsigned int D.24270;
  int D.24271;
  int D.24272;
  unsigned int D.24273;
  unsigned char D.24274;
  int D.24277;
  long unsigned int D.24278;
  long unsigned int D.24279;
  long unsigned int D.24280;
  struct MonoArrayBounds * D.24281;
  long unsigned int D.24284;
  long unsigned int D.24285;
  int D.24286;
  struct MonoClass * klass;

  D.24266 = o->vtable;
  klass = D.24266->klass;
  D.24267 = mono_defaults.string_class;
  if (D.24267 == klass) goto <D.24268>; else goto <D.24269>;
  <D.24268>:
  D.24271 = mono_string_length (o);
  D.24272 = D.24271 * 2;
  D.24273 = (unsigned int) D.24272;
  D.24270 = D.24273 + 26;
  return D.24270;
  <D.24269>:
  D.24266 = o->vtable;
  D.24274 = D.24266->rank;
  if (D.24274 != 0) goto <D.24275>; else goto <D.24276>;
  <D.24275>:
  {
    struct MonoArray * array;
    size_t size;

    array = o;
    D.24277 = mono_array_element_size (klass);
    D.24278 = (long unsigned int) D.24277;
    D.24279 = mono_array_length (array);
    D.24280 = D.24278 * D.24279;
    size = D.24280 + 32;
    D.24281 = array->bounds;
    if (D.24281 != 0B) goto <D.24282>; else goto <D.24283>;
    <D.24282>:
    size = size + 3;
    size = size & 18446744073709551612;
    D.24266 = o->vtable;
    D.24274 = D.24266->rank;
    D.24284 = (long unsigned int) D.24274;
    D.24285 = D.24284 * 8;
    size = D.24285 + size;
    <D.24283>:
    D.24270 = (unsigned int) size;
    return D.24270;
  }
  <D.24276>:
  D.24286 = mono_class_instance_size (klass);
  D.24270 = (unsigned int) D.24286;
  return D.24270;
}


mono_object_unbox (struct MonoObject * obj)
{
  struct MonoVTable * D.24288;
  struct MonoClass * D.24289;
  long unsigned int D.24290;
  long unsigned int D.24291;
  _Bool D.24292;
  long int D.24293;
  long int D.24294;
  void * D.24297;

  D.24288 = obj->vtable;
  D.24289 = D.24288->klass;
  D.24290 = BIT_FIELD_REF <*D.24289, 64, 256>;
  D.24291 = D.24290 & 1152921504606846976;
  D.24292 = D.24291 == 0;
  D.24293 = (long int) D.24292;
  D.24294 = __builtin_expect (D.24293, 0);
  if (D.24294 != 0) goto <D.24295>; else goto <D.24296>;
  <D.24295>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 5233, "obj->vtable->klass->valuetype");
  <D.24296>:
  D.24297 = obj + 16;
  return D.24297;
}


mono_object_isinst (struct MonoObject * obj, struct MonoClass * klass)
{
  long unsigned int D.24299;
  long unsigned int D.24300;
  long unsigned int D.24305;
  unsigned int D.24307;
  unsigned int D.24308;
  struct MonoObject * D.24309;
  struct MonoObject * iftmp.150;
  struct MonoVTable * D.24313;
  struct MonoClass * D.24314;
  int D.24315;

  D.24299 = BIT_FIELD_REF <*klass, 64, 256>;
  D.24300 = D.24299 & 9223372036854775808;
  if (D.24300 == 0) goto <D.24301>; else goto <D.24302>;
  <D.24301>:
  mono_class_init (klass);
  <D.24302>:
  D.24299 = BIT_FIELD_REF <*klass, 64, 256>;
  D.24305 = D.24299 & 2199023255552;
  if (D.24305 != 0) goto <D.24303>; else goto <D.24306>;
  <D.24306>:
  D.24307 = klass->flags;
  D.24308 = D.24307 & 32;
  if (D.24308 != 0) goto <D.24303>; else goto <D.24304>;
  <D.24303>:
  D.24309 = mono_object_isinst_mbyref (obj, klass);
  return D.24309;
  <D.24304>:
  if (obj == 0B) goto <D.24310>; else goto <D.24311>;
  <D.24310>:
  D.24309 = 0B;
  return D.24309;
  <D.24311>:
  D.24313 = obj->vtable;
  D.24314 = D.24313->klass;
  D.24315 = mono_class_is_assignable_from (klass, D.24314);
  if (D.24315 != 0) goto <D.24316>; else goto <D.24317>;
  <D.24316>:
  iftmp.150 = obj;
  goto <D.24318>;
  <D.24317>:
  iftmp.150 = 0B;
  <D.24318>:
  D.24309 = iftmp.150;
  return D.24309;
}


mono_object_isinst_mbyref (struct MonoObject * obj, struct MonoClass * klass)
{
  struct MonoObject * D.24322;
  unsigned int D.24323;
  unsigned int D.24324;
  short unsigned int D.24327;
  short unsigned int D.24328;
  guint8 * D.24331;
  short unsigned int D.24332;
  sizetype D.24333;
  guint8 * D.24334;
  unsigned char D.24335;
  int D.24336;
  int D.24337;
  int D.24338;
  int D.24339;
  int D.24340;
  int D.24343;
  struct MonoVTable * D.24346;
  struct MonoClass * D.24347;
  int D.24348;
  struct MonoClass * D.24352;
  struct MonoRemoteClass * D.24355;
  short unsigned int D.24356;
  short unsigned int D.24357;
  struct MonoClass * * D.24360;
  long unsigned int D.24361;
  long unsigned int D.24362;
  sizetype D.24363;
  struct MonoClass * * D.24364;
  struct MonoClass * D.24365;
  struct MonoClass * D.24368;
  unsigned char D.24371;
  _Bool D.24374;
  long int D.24375;
  long int D.24376;
  struct MonoType * D.24379;
  struct MonoReflectionType * D.24380;
  void * D.24381;
  unsigned char D.24382;
  struct MonoVTable * vt;

  if (obj == 0B) goto <D.24320>; else goto <D.24321>;
  <D.24320>:
  D.24322 = 0B;
  return D.24322;
  <D.24321>:
  vt = obj->vtable;
  D.24323 = klass->flags;
  D.24324 = D.24323 & 32;
  if (D.24324 != 0) goto <D.24325>; else goto <D.24326>;
  <D.24325>:
  D.24327 = klass->interface_id;
  D.24328 = vt->max_interface_id;
  if (D.24327 <= D.24328) goto <D.24329>; else goto <D.24330>;
  <D.24329>:
  D.24331 = vt->interface_bitmap;
  D.24327 = klass->interface_id;
  D.24332 = D.24327 >> 3;
  D.24333 = (sizetype) D.24332;
  D.24334 = D.24331 + D.24333;
  D.24335 = *D.24334;
  D.24336 = (int) D.24335;
  D.24327 = klass->interface_id;
  D.24337 = (int) D.24327;
  D.24338 = D.24337 & 7;
  D.24339 = D.24336 >> D.24338;
  D.24340 = D.24339 & 1;
  if (D.24340 != 0) goto <D.24341>; else goto <D.24342>;
  <D.24341>:
  D.24322 = obj;
  return D.24322;
  <D.24342>:
  <D.24330>:
  D.24343 = mono_class_has_variant_generic_params (klass);
  if (D.24343 != 0) goto <D.24344>; else goto <D.24345>;
  <D.24344>:
  D.24346 = obj->vtable;
  D.24347 = D.24346->klass;
  D.24348 = mono_class_is_assignable_from (klass, D.24347);
  if (D.24348 != 0) goto <D.24349>; else goto <D.24350>;
  <D.24349>:
  D.24322 = obj;
  return D.24322;
  <D.24350>:
  <D.24345>:
  goto <D.24351>;
  <D.24326>:
  {
    struct MonoClass * oklass;

    oklass = vt->klass;
    D.24352 = mono_defaults.transparent_proxy_class;
    if (D.24352 == oklass) goto <D.24353>; else goto <D.24354>;
    <D.24353>:
    D.24355 = MEM[(struct MonoTransparentProxy *)obj].remote_class;
    oklass = D.24355->proxy_class;
    <D.24354>:
    mono_class_setup_supertypes (klass);
    D.24356 = oklass->idepth;
    D.24357 = klass->idepth;
    if (D.24356 >= D.24357) goto <D.24358>; else goto <D.24359>;
    <D.24358>:
    D.24360 = oklass->supertypes;
    D.24357 = klass->idepth;
    D.24361 = (long unsigned int) D.24357;
    D.24362 = D.24361 * 8;
    D.24363 = D.24362 + 18446744073709551608;
    D.24364 = D.24360 + D.24363;
    D.24365 = *D.24364;
    if (D.24365 == klass) goto <D.24366>; else goto <D.24367>;
    <D.24366>:
    D.24322 = obj;
    return D.24322;
    <D.24367>:
    <D.24359>:
  }
  <D.24351>:
  D.24368 = vt->klass;
  D.24352 = mono_defaults.transparent_proxy_class;
  if (D.24368 == D.24352) goto <D.24369>; else goto <D.24370>;
  <D.24369>:
  D.24371 = MEM[(struct MonoTransparentProxy *)obj].custom_type_info;
  if (D.24371 != 0) goto <D.24372>; else goto <D.24373>;
  <D.24372>:
  {
    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.24374 = im == 0B;
        D.24375 = (long int) D.24374;
        D.24376 = __builtin_expect (D.24375, 0);
        if (D.24376 != 0) goto <D.24377>; else goto <D.24378>;
        <D.24377>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 5298, "im");
        <D.24378>:
        D.24379 = &klass->byval_arg;
        D.24380 = mono_type_get_object (domain, D.24379);
        pa[0] = D.24380;
        pa[1] = obj;
        res = mono_runtime_invoke (im, rp, &pa, 0B);
        D.24381 = mono_object_unbox (res);
        D.24382 = MEM[(MonoBoolean *)D.24381];
        if (D.24382 != 0) goto <D.24383>; else goto <D.24384>;
        <D.24383>:
        mono_upgrade_remote_class (domain, obj, klass);
        D.24322 = obj;
        return D.24322;
        <D.24384>:
      }
    finally
      {
        pa = {CLOBBER};
      }
  }
  <D.24373>:
  <D.24370>:
  D.24322 = 0B;
  return D.24322;
}


mono_object_castclass_mbyref (struct MonoObject * obj, struct MonoClass * klass)
{
  struct MonoObject * D.24390;
  struct MonoObject * D.24391;
  struct MonoImage * D.24394;
  struct MonoException * D.24395;

  if (obj == 0B) goto <D.24388>; else goto <D.24389>;
  <D.24388>:
  D.24390 = 0B;
  return D.24390;
  <D.24389>:
  D.24391 = mono_object_isinst_mbyref (obj, klass);
  if (D.24391 != 0B) goto <D.24392>; else goto <D.24393>;
  <D.24392>:
  D.24390 = obj;
  return D.24390;
  <D.24393>:
  D.24394 = mono_defaults.corlib;
  D.24395 = mono_exception_from_name (D.24394, "System", "InvalidCastException");
  mono_raise_exception (D.24395);
  D.24390 = 0B;
  return D.24390;
}


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

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


mono_string_is_interned_lookup (struct MonoString * str, int insert)
{
  struct MonoVTable * D.24399;
  _Bool D.24402;
  long int D.24403;
  long int D.24404;
  _Bool D.24411;
  long int D.24412;
  long int D.24413;
  struct MonoString * D.24416;
  _Bool D.24423;
  long int D.24424;
  long int D.24425;
  struct MonoString * D.24428;
  _Bool D.24433;
  long int D.24434;
  long int D.24435;
  _Bool D.24440;
  long int D.24441;
  long int D.24442;
  struct MonoGHashTable * ldstr_table;
  struct MonoString * res;
  struct MonoDomain * domain;

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

    ret = pthread_mutex_lock (&ldstr_section.mutex);
    if (ret != 0) goto <D.24400>; else goto <D.24401>;
    <D.24400>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
    <D.24401>:
    D.24402 = ret != 0;
    D.24403 = (long int) D.24402;
    D.24404 = __builtin_expect (D.24403, 0);
    if (D.24404 != 0) goto <D.24405>; else goto <D.24406>;
    <D.24405>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 5378, "ret == 0");
    <D.24406>:
  }
  res = mono_g_hash_table_lookup (ldstr_table, str);
  if (res != 0B) goto <D.24407>; else goto <D.24408>;
  <D.24407>:
  {
    int ret;

    ret = pthread_mutex_unlock (&ldstr_section.mutex);
    if (ret != 0) goto <D.24409>; else goto <D.24410>;
    <D.24409>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.24410>:
    D.24411 = ret != 0;
    D.24412 = (long int) D.24411;
    D.24413 = __builtin_expect (D.24412, 0);
    if (D.24413 != 0) goto <D.24414>; else goto <D.24415>;
    <D.24414>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 5380, "ret == 0");
    <D.24415>:
  }
  D.24416 = res;
  return D.24416;
  <D.24408>:
  if (insert != 0) goto <D.24417>; else goto <D.24418>;
  <D.24417>:
  str = mono_string_get_pinned (str);
  if (str != 0B) goto <D.24419>; else goto <D.24420>;
  <D.24419>:
  mono_g_hash_table_insert (ldstr_table, str, str);
  <D.24420>:
  {
    int ret;

    ret = pthread_mutex_unlock (&ldstr_section.mutex);
    if (ret != 0) goto <D.24421>; else goto <D.24422>;
    <D.24421>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.24422>:
    D.24423 = ret != 0;
    D.24424 = (long int) D.24423;
    D.24425 = __builtin_expect (D.24424, 0);
    if (D.24425 != 0) goto <D.24426>; else goto <D.24427>;
    <D.24426>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 5387, "ret == 0");
    <D.24427>:
  }
  D.24416 = str;
  return D.24416;
  <D.24418>:
  {
    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.24428 = ldstr_info.res;
        if (D.24428 != 0B) goto <D.24429>; else goto <D.24430>;
        <D.24429>:
        mono_g_hash_table_insert (ldstr_table, str, str);
        {
          int ret;

          ret = pthread_mutex_unlock (&ldstr_section.mutex);
          if (ret != 0) goto <D.24431>; else goto <D.24432>;
          <D.24431>:
          monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
          <D.24432>:
          D.24433 = ret != 0;
          D.24434 = (long int) D.24433;
          D.24435 = __builtin_expect (D.24434, 0);
          if (D.24435 != 0) goto <D.24436>; else goto <D.24437>;
          <D.24436>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 5402, "ret == 0");
          <D.24437>:
        }
        D.24416 = str;
        return D.24416;
        <D.24430>:
      }
    finally
      {
        ldstr_info = {CLOBBER};
      }
  }
  {
    int ret;

    ret = pthread_mutex_unlock (&ldstr_section.mutex);
    if (ret != 0) goto <D.24438>; else goto <D.24439>;
    <D.24438>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.24439>:
    D.24440 = ret != 0;
    D.24441 = (long int) D.24440;
    D.24442 = __builtin_expect (D.24441, 0);
    if (D.24442 != 0) goto <D.24443>; else goto <D.24444>;
    <D.24443>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 5406, "ret == 0");
    <D.24444>:
  }
  D.24416 = 0B;
  return D.24416;
}


str_lookup (struct MonoDomain * domain, void * user_data)
{
  struct MonoString * D.24450;
  struct MonoDomain * D.24452;
  struct MonoGHashTable * D.24453;
  struct MonoString * D.24454;
  void * D.24455;
  struct LDStrInfo * info;

  info = user_data;
  D.24450 = info->res;
  if (D.24450 != 0B) goto <D.24448>; else goto <D.24451>;
  <D.24451>:
  D.24452 = info->orig_domain;
  if (D.24452 == domain) goto <D.24448>; else goto <D.24449>;
  <D.24448>:
  return;
  <D.24449>:
  D.24453 = domain->ldstr_table;
  D.24454 = info->ins;
  D.24455 = mono_g_hash_table_lookup (D.24453, D.24454);
  info->res = D.24455;
}


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

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


mono_ldstr (struct MonoDomain * domain, struct MonoImage * image, guint32 idx)
{
  long unsigned int D.24459;
  long unsigned int D.24460;
  unsigned int D.24463;
  struct MonoString * D.24464;
  int D.24465;
  const char * D.24468;

  D.24459 = BIT_FIELD_REF <*image, 64, 192>;
  D.24460 = D.24459 & 268435456;
  if (D.24460 != 0) goto <D.24461>; else goto <D.24462>;
  <D.24461>:
  {
    struct MonoString * str;

    D.24463 = idx | 1879048192;
    str = mono_lookup_dynamic_token (image, D.24463, 0B);
    D.24464 = str;
    return D.24464;
  }
  <D.24462>:
  D.24465 = mono_verifier_verify_string_signature (image, idx, 0B);
  if (D.24465 == 0) goto <D.24466>; else goto <D.24467>;
  <D.24466>:
  D.24464 = 0B;
  return D.24464;
  <D.24467>:
  D.24468 = mono_metadata_user_string (image, idx);
  D.24464 = mono_ldstr_metadata_sig (domain, D.24468);
  return D.24464;
}


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

  try
    {
      result = mono_string_to_utf8_checked (s, &error);
      D.24470 = mono_error_ok (&error);
      if (D.24470 == 0) goto <D.24471>; else goto <D.24472>;
      <D.24471>:
      mono_error_raise_exception (&error);
      <D.24472>:
      D.24473 = result;
      return D.24473;
    }
  finally
    {
      error = {CLOBBER};
    }
}


mono_string_to_utf8_checked (struct MonoString * s, struct MonoError * error)
{
  char * D.24478;
  int D.24479;
  mono_unichar2 * D.24482;
  long int D.24483;
  struct GError * gerror.151;
  gchar * D.24487;
  long int D.24488;
  long int written.152;
  long unsigned int D.24492;
  long unsigned int written.153;
  long int written;
  char * as;
  struct GError * gerror;

  try
    {
      written = 0;
      gerror = 0B;
      mono_error_init (error);
      if (s == 0B) goto <D.24476>; else goto <D.24477>;
      <D.24476>:
      D.24478 = 0B;
      return D.24478;
      <D.24477>:
      D.24479 = s->length;
      if (D.24479 == 0) goto <D.24480>; else goto <D.24481>;
      <D.24480>:
      D.24478 = monoeg_strdup ("");
      return D.24478;
      <D.24481>:
      D.24482 = mono_string_chars (s);
      D.24479 = s->length;
      D.24483 = (long int) D.24479;
      as = monoeg_g_utf16_to_utf8 (D.24482, D.24483, 0B, &written, &gerror);
      gerror.151 = gerror;
      if (gerror.151 != 0B) goto <D.24485>; else goto <D.24486>;
      <D.24485>:
      gerror.151 = gerror;
      D.24487 = gerror.151->message;
      mono_error_set_argument (error, "string", "%s", D.24487);
      gerror.151 = gerror;
      monoeg_g_error_free (gerror.151);
      D.24478 = 0B;
      return D.24478;
      <D.24486>:
      D.24479 = s->length;
      D.24488 = (long int) D.24479;
      written.152 = written;
      if (D.24488 > written.152) goto <D.24490>; else goto <D.24491>;
      <D.24490>:
      {
        char * as2;

        D.24479 = s->length;
        D.24492 = (long unsigned int) D.24479;
        as2 = monoeg_malloc0 (D.24492);
        written.152 = written;
        written.153 = (long unsigned int) written.152;
        memcpy (as2, as, written.153);
        monoeg_g_free (as);
        as = as2;
      }
      <D.24491>:
      D.24478 = as;
      return D.24478;
    }
  finally
    {
      written = {CLOBBER};
      gerror = {CLOBBER};
    }
}


__attribute__((visibility ("hidden")))
mono_string_to_utf8_ignore (struct MonoString * s)
{
  char * D.24498;
  int D.24499;
  mono_unichar2 * D.24502;
  long int D.24503;
  long int D.24504;
  long int written.154;
  long unsigned int D.24508;
  long unsigned int written.155;
  long int written;
  char * as;

  try
    {
      written = 0;
      if (s == 0B) goto <D.24496>; else goto <D.24497>;
      <D.24496>:
      D.24498 = 0B;
      return D.24498;
      <D.24497>:
      D.24499 = s->length;
      if (D.24499 == 0) goto <D.24500>; else goto <D.24501>;
      <D.24500>:
      D.24498 = monoeg_strdup ("");
      return D.24498;
      <D.24501>:
      D.24502 = mono_string_chars (s);
      D.24499 = s->length;
      D.24503 = (long int) D.24499;
      as = monoeg_g_utf16_to_utf8 (D.24502, D.24503, 0B, &written, 0B);
      D.24499 = s->length;
      D.24504 = (long int) D.24499;
      written.154 = written;
      if (D.24504 > written.154) goto <D.24506>; else goto <D.24507>;
      <D.24506>:
      {
        char * as2;

        D.24499 = s->length;
        D.24508 = (long unsigned int) D.24499;
        as2 = monoeg_malloc0 (D.24508);
        written.154 = written;
        written.155 = (long unsigned int) written.154;
        memcpy (as2, as, written.155);
        monoeg_g_free (as);
        as = as2;
      }
      <D.24507>:
      D.24498 = as;
      return D.24498;
    }
  finally
    {
      written = {CLOBBER};
    }
}


__attribute__((visibility ("hidden")))
mono_string_to_utf8_image_ignore (struct MonoImage * image, struct MonoString * s)
{
  char * D.24512;

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


mono_string_to_utf8_internal (struct MonoMemPool * mp, struct MonoImage * image, struct MonoString * s, gboolean ignore_error, struct MonoError * error)
{
  int D.24517;
  char * D.24520;
  long unsigned int D.24525;
  unsigned int D.24526;
  unsigned int D.24527;
  unsigned int len.156;
  unsigned int len.157;
  long unsigned int D.24533;
  char * r;
  char * mp_s;
  int len;

  if (ignore_error != 0) goto <D.24514>; else goto <D.24515>;
  <D.24514>:
  r = mono_string_to_utf8_ignore (s);
  goto <D.24516>;
  <D.24515>:
  r = mono_string_to_utf8_checked (s, error);
  D.24517 = mono_error_ok (error);
  if (D.24517 == 0) goto <D.24518>; else goto <D.24519>;
  <D.24518>:
  D.24520 = 0B;
  return D.24520;
  <D.24519>:
  <D.24516>:
  if (mp == 0B) goto <D.24521>; else goto <D.24522>;
  <D.24521>:
  if (image == 0B) goto <D.24523>; else goto <D.24524>;
  <D.24523>:
  D.24520 = r;
  return D.24520;
  <D.24524>:
  <D.24522>:
  D.24525 = __strlen_g (r);
  D.24526 = (unsigned int) D.24525;
  D.24527 = D.24526 + 1;
  len = (int) D.24527;
  if (mp != 0B) goto <D.24528>; else goto <D.24529>;
  <D.24528>:
  len.156 = (unsigned int) len;
  mp_s = mono_mempool_alloc (mp, len.156);
  goto <D.24531>;
  <D.24529>:
  len.157 = (unsigned int) len;
  mp_s = mono_image_alloc (image, len.157);
  <D.24531>:
  D.24533 = (long unsigned int) len;
  memcpy (mp_s, r, D.24533);
  monoeg_g_free (r);
  D.24520 = mp_s;
  return D.24520;
}


__attribute__((visibility ("hidden")))
mono_string_to_utf8_mp_ignore (struct MonoMemPool * mp, struct MonoString * s)
{
  char * D.24535;

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


mono_string_to_utf16 (struct MonoString * s)
{
  mono_unichar2 * D.24539;
  int D.24540;
  int D.24541;
  int D.24542;
  long unsigned int D.24543;
  int D.24544;
  sizetype D.24545;
  char * D.24546;
  sizetype D.24547;
  char * D.24548;
  mono_unichar2 * D.24551;
  long unsigned int D.24552;
  char * as;

  if (s == 0B) goto <D.24537>; else goto <D.24538>;
  <D.24537>:
  D.24539 = 0B;
  return D.24539;
  <D.24538>:
  D.24540 = s->length;
  D.24541 = D.24540 + 1;
  D.24542 = D.24541 * 2;
  D.24543 = (long unsigned int) D.24542;
  as = monoeg_malloc (D.24543);
  D.24540 = s->length;
  D.24544 = D.24540 * 2;
  D.24545 = (sizetype) D.24544;
  D.24546 = as + D.24545;
  *D.24546 = 0;
  D.24540 = s->length;
  D.24544 = D.24540 * 2;
  D.24545 = (sizetype) D.24544;
  D.24547 = D.24545 + 1;
  D.24548 = as + D.24547;
  *D.24548 = 0;
  D.24540 = s->length;
  if (D.24540 == 0) goto <D.24549>; else goto <D.24550>;
  <D.24549>:
  D.24539 = as;
  return D.24539;
  <D.24550>:
  D.24551 = mono_string_chars (s);
  D.24540 = s->length;
  D.24544 = D.24540 * 2;
  D.24552 = (long unsigned int) D.24544;
  memcpy (as, D.24551, D.24552);
  D.24539 = as;
  return D.24539;
}


mono_string_from_utf16 (gunichar2 * data)
{
  struct MonoString * D.24556;
  long unsigned int D.24557;
  long unsigned int D.24558;
  gunichar2 * D.24559;
  short unsigned int D.24560;
  struct MonoDomain * domain;
  int len;

  domain = mono_domain_get ();
  len = 0;
  if (data == 0B) goto <D.24554>; else goto <D.24555>;
  <D.24554>:
  D.24556 = 0B;
  return D.24556;
  <D.24555>:
  goto <D.20554>;
  <D.20553>:
  len = len + 1;
  <D.20554>:
  D.24557 = (long unsigned int) len;
  D.24558 = D.24557 * 2;
  D.24559 = data + D.24558;
  D.24560 = *D.24559;
  if (D.24560 != 0) goto <D.20553>; else goto <D.20555>;
  <D.20555>:
  D.24556 = mono_string_new_utf16 (domain, data, len);
  return D.24556;
}


__attribute__((visibility ("hidden")))
mono_string_to_utf8_image (struct MonoImage * image, struct MonoString * s, struct MonoError * error)
{
  char * D.24562;

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


__attribute__((visibility ("hidden")))
mono_string_to_utf8_mp (struct MonoMemPool * mp, struct MonoString * s, struct MonoError * error)
{
  char * D.24564;

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


__attribute__((visibility ("hidden")))
mono_install_eh_callbacks (struct MonoRuntimeExceptionHandlingCallbacks * cbs)
{
  eh_callbacks = *cbs;
}


__attribute__((visibility ("hidden")))
mono_get_eh_callbacks ()
{
  struct MonoRuntimeExceptionHandlingCallbacks * D.24566;

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


mono_raise_exception (struct MonoException * ex)
{
  void (*<T26be>) (struct MonoException *) D.24568;

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


__attribute__((visibility ("hidden")))
mono_raise_exception_with_context (struct MonoException * ex, struct MonoContext * ctx)
{
  void (*<T26c2>) (struct MonoException *, struct MonoContext *) D.24569;

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


__attribute__((visibility ("hidden")))
mono_wait_handle_new (struct MonoDomain * domain, void * handle)
{
  struct MonoClass * D.24570;
  struct MonoMethod * handle_set.158;
  struct MonoProperty * D.24574;
  struct MonoMethod * handle_set.159;
  struct MonoWaitHandle * D.24576;
  struct MonoWaitHandle * res;
  void * params[1];
  static struct MonoMethod * handle_set;

  try
    {
      D.24570 = mono_defaults.manualresetevent_class;
      res = mono_object_new (domain, D.24570);
      handle_set.158 = handle_set;
      if (handle_set.158 == 0B) goto <D.24572>; else goto <D.24573>;
      <D.24572>:
      D.24570 = mono_defaults.manualresetevent_class;
      D.24574 = mono_class_get_property_from_name (D.24570, "Handle");
      handle_set.159 = D.24574->set;
      handle_set = handle_set.159;
      <D.24573>:
      params[0] = &handle;
      handle_set.158 = handle_set;
      mono_runtime_invoke (handle_set.158, res, &params, 0B);
      D.24576 = res;
      return D.24576;
    }
  finally
    {
      params = {CLOBBER};
    }
}


__attribute__((visibility ("hidden")))
mono_wait_handle_get_handle (struct MonoWaitHandle * handle)
{
  struct MonoClassField * f_os_handle.160;
  struct MonoClassField * f_safe_handle.161;
  struct MonoClass * D.24585;
  struct MonoClassField * f_os_handle.162;
  struct MonoClassField * f_safe_handle.163;
  void * D.24590;
  struct MonoSafeHandle * sh.164;
  static struct MonoClassField * f_os_handle;
  static struct MonoClassField * f_safe_handle;

  f_os_handle.160 = f_os_handle;
  if (f_os_handle.160 == 0B) goto <D.24580>; else goto <D.24581>;
  <D.24580>:
  f_safe_handle.161 = f_safe_handle;
  if (f_safe_handle.161 == 0B) goto <D.24583>; else goto <D.24584>;
  <D.24583>:
  D.24585 = mono_defaults.manualresetevent_class;
  f_os_handle.162 = mono_class_get_field_from_name (D.24585, "os_handle");
  f_os_handle = f_os_handle.162;
  D.24585 = mono_defaults.manualresetevent_class;
  f_safe_handle.163 = mono_class_get_field_from_name (D.24585, "safe_wait_handle");
  f_safe_handle = f_safe_handle.163;
  <D.24584>:
  <D.24581>:
  f_os_handle.160 = f_os_handle;
  if (f_os_handle.160 != 0B) goto <D.24588>; else goto <D.24589>;
  <D.24588>:
  {
    void * retval;

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

    try
      {
        f_safe_handle.161 = f_safe_handle;
        mono_field_get_value (handle, f_safe_handle.161, &sh);
        sh.164 = sh;
        D.24590 = sh.164->handle;
        return D.24590;
      }
    finally
      {
        sh = {CLOBBER};
      }
  }
}


__attribute__((visibility ("hidden")))
mono_async_result_new (struct MonoDomain * domain, void * handle, struct MonoObject * state, void * data, struct MonoObject * object_data)
{
  struct MonoClass * D.24595;
  struct MonoObject * * D.24598;
  struct MonoObject * * D.24599;
  struct MonoObject * * D.24600;
  struct MonoObject * * D.24603;
  struct MonoWaitHandle * D.24604;
  struct MonoAsyncResult * D.24605;
  struct MonoAsyncResult * res;
  struct MonoObject * context;

  D.24595 = mono_defaults.asyncresult_class;
  res = mono_object_new (domain, D.24595);
  context = mono_runtime_capture_context (domain);
  if (context != 0B) goto <D.24596>; else goto <D.24597>;
  <D.24596>:
  D.24598 = &res->execution_context;
  mono_gc_wbarrier_set_field (res, D.24598, context);
  <D.24597>:
  res->data = data;
  D.24599 = &res->object_data;
  mono_gc_wbarrier_set_field (res, D.24599, object_data);
  D.24600 = &res->async_state;
  mono_gc_wbarrier_set_field (res, D.24600, state);
  if (handle != 0B) goto <D.24601>; else goto <D.24602>;
  <D.24601>:
  D.24603 = &res->handle;
  D.24604 = mono_wait_handle_new (domain, handle);
  mono_gc_wbarrier_set_field (res, D.24603, D.24604);
  <D.24602>:
  res->sync_completed = 0;
  res->completed = 0;
  D.24605 = res;
  return D.24605;
}


mono_runtime_capture_context (struct MonoDomain * domain)
{
  void * D.24609;
  void * D.24611;
  struct MonoObject * D.24614;
  void * D.24615;
  void * D.24616;
  struct MonoObject * (*RuntimeInvokeFunction) (struct MonoObject *, void * *, struct MonoObject * *, void *) runtime_invoke;

  D.24609 = domain->capture_context_runtime_invoke;
  if (D.24609 == 0B) goto <D.24607>; else goto <D.24610>;
  <D.24610>:
  D.24611 = domain->capture_context_method;
  if (D.24611 == 0B) goto <D.24607>; else goto <D.24608>;
  <D.24607>:
  {
    struct MonoMethod * method;
    struct MonoMethod * wrapper;

    method = mono_get_context_capture_method ();
    if (method == 0B) goto <D.24612>; else goto <D.24613>;
    <D.24612>:
    D.24614 = 0B;
    return D.24614;
    <D.24613>:
    wrapper = mono_marshal_get_runtime_invoke (method, 0);
    D.24615 = mono_compile_method (wrapper);
    domain->capture_context_runtime_invoke = D.24615;
    D.24616 = mono_compile_method (method);
    domain->capture_context_method = D.24616;
  }
  <D.24608>:
  D.24609 = domain->capture_context_runtime_invoke;
  runtime_invoke = (struct MonoObject * (*RuntimeInvokeFunction) (struct MonoObject *, void * *, struct MonoObject * *, void *)) D.24609;
  D.24611 = domain->capture_context_method;
  D.24614 = runtime_invoke (0B, 0B, 0B, D.24611);
  return D.24614;
}


__attribute__((visibility ("hidden")))
mono_message_init (struct MonoDomain * domain, struct MonoMethodMessage * this, struct MonoReflectionMethod * method, struct MonoArray * out_args)
{
  struct MonoMethod * D.24618;
  struct MonoClass * object_array_klass.165;
  struct MonoClass * D.24622;
  _Bool D.24623;
  long int D.24624;
  long int D.24625;
  struct MonoClass * D.24628;
  struct MonoClass * D.24631;
  struct MonoReflectionMethod * * D.24634;
  struct MonoArray * * D.24635;
  struct MonoVTable * D.24636;
  short unsigned int D.24637;
  long unsigned int D.24638;
  struct MonoArray * D.24639;
  struct MonoArray * * D.24640;
  struct MonoClass * byte_array_klass.166;
  struct MonoVTable * D.24642;
  struct MonoArray * D.24643;
  long unsigned int D.24644;
  long unsigned int D.24645;
  struct MonoArray * * D.24646;
  struct MonoClass * string_array_klass.167;
  struct MonoVTable * D.24648;
  struct MonoArray * D.24649;
  long unsigned int D.24650;
  long unsigned int D.24651;
  char * * D.24652;
  char * D.24653;
  struct MonoArray * D.24654;
  long unsigned int D.24655;
  int D.24656;
  struct MonoType * D.24657;
  long unsigned int D.24658;
  long unsigned int D.24659;
  long unsigned int D.24664;
  char * D.24665;
  struct MonoArray * D.24666;
  short unsigned int D.24667;
  int D.24668;
  int D.24669;
  struct MonoArray * D.24675;
  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.24618 = method->method;
  sig = mono_method_signature (D.24618);
  object_array_klass.165 = object_array_klass;
  if (object_array_klass.165 == 0B) goto <D.24620>; else goto <D.24621>;
  <D.24620>:
  {
    struct MonoClass * klass;

    D.24622 = mono_defaults.byte_class;
    klass = mono_array_class_get (D.24622, 1);
    D.24623 = klass == 0B;
    D.24624 = (long int) D.24623;
    D.24625 = __builtin_expect (D.24624, 0);
    if (D.24625 != 0) goto <D.24626>; else goto <D.24627>;
    <D.24626>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 5891, "klass");
    <D.24627>:
    byte_array_klass = klass;
    D.24628 = mono_defaults.string_class;
    klass = mono_array_class_get (D.24628, 1);
    D.24623 = klass == 0B;
    D.24624 = (long int) D.24623;
    D.24625 = __builtin_expect (D.24624, 0);
    if (D.24625 != 0) goto <D.24629>; else goto <D.24630>;
    <D.24629>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 5895, "klass");
    <D.24630>:
    string_array_klass = klass;
    D.24631 = mono_defaults.object_class;
    klass = mono_array_class_get (D.24631, 1);
    D.24623 = klass == 0B;
    D.24624 = (long int) D.24623;
    D.24625 = __builtin_expect (D.24624, 0);
    if (D.24625 != 0) goto <D.24632>; else goto <D.24633>;
    <D.24632>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 5899, "klass");
    <D.24633>:
    object_array_klass = klass;
  }
  <D.24621>:
  D.24634 = &this->method;
  mono_gc_wbarrier_set_field (this, D.24634, method);
  D.24635 = &this->args;
  object_array_klass.165 = object_array_klass;
  D.24636 = mono_class_vtable (domain, object_array_klass.165);
  D.24637 = sig->param_count;
  D.24638 = (long unsigned int) D.24637;
  D.24639 = mono_array_new_specific (D.24636, D.24638);
  mono_gc_wbarrier_set_field (this, D.24635, D.24639);
  D.24640 = &this->arg_types;
  byte_array_klass.166 = byte_array_klass;
  D.24642 = mono_class_vtable (domain, byte_array_klass.166);
  D.24637 = sig->param_count;
  D.24638 = (long unsigned int) D.24637;
  D.24643 = mono_array_new_specific (D.24642, D.24638);
  mono_gc_wbarrier_set_field (this, D.24640, D.24643);
  this->async_result = 0B;
  this->call_type = 0;
  D.24637 = sig->param_count;
  D.24644 = (long unsigned int) D.24637;
  D.24645 = D.24644 * 8;
  names = monoeg_malloc (D.24645);
  D.24618 = method->method;
  mono_method_get_param_names (D.24618, names);
  D.24646 = &this->names;
  string_array_klass.167 = string_array_klass;
  D.24648 = mono_class_vtable (domain, string_array_klass.167);
  D.24637 = sig->param_count;
  D.24638 = (long unsigned int) D.24637;
  D.24649 = mono_array_new_specific (D.24648, D.24638);
  mono_gc_wbarrier_set_field (this, D.24646, D.24649);
  i = 0;
  goto <D.20637>;
  <D.20636>:
  D.24650 = (long unsigned int) i;
  D.24651 = D.24650 * 8;
  D.24652 = names + D.24651;
  D.24653 = *D.24652;
  name = mono_string_new (domain, D.24653);
  {
    void * * __p;

    D.24654 = this->names;
    D.24655 = (long unsigned int) i;
    __p = mono_array_addr_with_size (D.24654, 8, D.24655);
    D.24654 = this->names;
    mono_gc_wbarrier_set_arrayref (D.24654, __p, name);
  }
  i = i + 1;
  <D.20637>:
  D.24637 = sig->param_count;
  D.24656 = (int) D.24637;
  if (D.24656 > i) goto <D.20636>; else goto <D.20638>;
  <D.20638>:
  monoeg_g_free (names);
  i = 0;
  j = 0;
  goto <D.20643>;
  <D.20642>:
  D.24657 = sig->params[i];
  D.24658 = BIT_FIELD_REF <*D.24657, 64, 64>;
  D.24659 = D.24658 & 8589934592;
  if (D.24659 != 0) goto <D.24660>; else goto <D.24661>;
  <D.24660>:
  if (out_args != 0B) goto <D.24662>; else goto <D.24663>;
  <D.24662>:
  {
    struct MonoObject * arg;

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

      D.24666 = this->args;
      D.24655 = (long unsigned int) i;
      __p = mono_array_addr_with_size (D.24666, 8, D.24655);
      D.24666 = this->args;
      mono_gc_wbarrier_set_arrayref (D.24666, __p, arg);
    }
    j = j + 1;
  }
  <D.24663>:
  arg_type = 2;
  D.24657 = sig->params[i];
  D.24667 = D.24657->attrs;
  D.24668 = (int) D.24667;
  D.24669 = D.24668 & 2;
  if (D.24669 == 0) goto <D.24670>; else goto <D.24671>;
  <D.24670>:
  arg_type = arg_type | 1;
  <D.24671>:
  goto <D.24672>;
  <D.24661>:
  arg_type = 1;
  D.24657 = sig->params[i];
  D.24667 = D.24657->attrs;
  D.24668 = (int) D.24667;
  D.24669 = D.24668 & 2;
  if (D.24669 != 0) goto <D.24673>; else goto <D.24674>;
  <D.24673>:
  arg_type = arg_type | 4;
  <D.24674>:
  <D.24672>:
  {
    guint8 * __p;

    D.24675 = this->arg_types;
    D.24655 = (long unsigned int) i;
    __p = mono_array_addr_with_size (D.24675, 1, D.24655);
    *__p = arg_type;
  }
  i = i + 1;
  <D.20643>:
  D.24637 = sig->param_count;
  D.24656 = (int) D.24637;
  if (D.24656 > i) goto <D.20642>; else goto <D.20644>;
  <D.20644>:
}


__attribute__((visibility ("hidden")))
mono_remoting_invoke (struct MonoObject * real_proxy, struct MonoMethodMessage * msg, struct MonoObject * * exc, struct MonoArray * * out_args)
{
  struct MonoVTable * D.24676;
  struct MonoDomain * D.24677;
  struct MonoClass * D.24680;
  _Bool D.24681;
  long int D.24682;
  long int D.24683;
  struct MonoObject * D.24686;
  struct MonoMethod * im;
  void * pa[4];

  try
    {
      D.24676 = real_proxy->vtable;
      D.24677 = D.24676->domain;
      im = D.24677->private_invoke_method;
      if (im == 0B) goto <D.24678>; else goto <D.24679>;
      <D.24678>:
      D.24680 = mono_defaults.real_proxy_class;
      im = mono_class_get_method_from_name (D.24680, "PrivateInvoke", 4);
      D.24681 = im == 0B;
      D.24682 = (long int) D.24681;
      D.24683 = __builtin_expect (D.24682, 0);
      if (D.24683 != 0) goto <D.24684>; else goto <D.24685>;
      <D.24684>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 5966, "im");
      <D.24685>:
      D.24676 = real_proxy->vtable;
      D.24677 = D.24676->domain;
      D.24677->private_invoke_method = im;
      <D.24679>:
      pa[0] = real_proxy;
      pa[1] = msg;
      pa[2] = exc;
      pa[3] = out_args;
      D.24686 = mono_runtime_invoke (im, 0B, &pa, exc);
      return D.24686;
    }
  finally
    {
      pa = {CLOBBER};
    }
}


__attribute__((visibility ("hidden")))
mono_message_invoke (struct MonoObject * target, struct MonoMethodMessage * msg, struct MonoObject * * exc, struct MonoArray * * out_args)
{
  struct MonoVTable * D.24691;
  struct MonoClass * D.24692;
  struct MonoClass * D.24693;
  struct MonoRemoteClass * D.24698;
  struct MonoClass * D.24699;
  long unsigned int D.24700;
  long unsigned int D.24701;
  struct MonoRealProxy * D.24703;
  struct MonoObject * D.24704;
  struct MonoAppContext * D.24705;
  struct MonoObject * D.24707;
  struct MonoReflectionMethod * D.24708;
  struct MonoType * D.24709;
  long unsigned int D.24710;
  long unsigned int D.24711;
  short unsigned int D.24714;
  int D.24715;
  struct MonoClass * object_array_klass.168;
  struct MonoClass * D.24719;
  _Bool D.24720;
  long int D.24721;
  long int D.24722;
  struct MonoVTable * D.24725;
  long unsigned int D.24726;
  struct MonoArray * D.24727;
  void * iftmp.169;
  struct MonoClass * D.24729;
  long unsigned int D.24730;
  long unsigned int D.24731;
  struct MonoArray * D.24735;
  long unsigned int D.24738;
  char * D.24739;
  struct MonoArray * D.24740;
  long unsigned int D.24741;
  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.24689>; else goto <D.24690>;
  <D.24689>:
  D.24691 = target->vtable;
  D.24692 = D.24691->klass;
  D.24693 = mono_defaults.transparent_proxy_class;
  if (D.24692 == D.24693) goto <D.24694>; else goto <D.24695>;
  <D.24694>:
  {
    struct MonoTransparentProxy * tp;

    tp = target;
    D.24698 = tp->remote_class;
    D.24699 = D.24698->proxy_class;
    D.24700 = BIT_FIELD_REF <*D.24699, 64, 256>;
    D.24701 = D.24700 & 1099511627776;
    if (D.24701 != 0) goto <D.24702>; else goto <D.24696>;
    <D.24702>:
    D.24703 = tp->rp;
    D.24704 = D.24703->context;
    D.24705 = mono_context_get ();
    if (D.24704 == D.24705) goto <D.24706>; else goto <D.24696>;
    <D.24706>:
    D.24703 = tp->rp;
    target = D.24703->unwrapped_server;
    goto <D.24697>;
    <D.24696>:
    D.24703 = tp->rp;
    D.24707 = mono_remoting_invoke (D.24703, msg, exc, out_args);
    return D.24707;
    <D.24697>:
  }
  <D.24695>:
  <D.24690>:
  domain = mono_domain_get ();
  D.24708 = msg->method;
  method = D.24708->method;
  sig = mono_method_signature (method);
  i = 0;
  goto <D.20669>;
  <D.20668>:
  D.24709 = sig->params[i];
  D.24710 = BIT_FIELD_REF <*D.24709, 64, 64>;
  D.24711 = D.24710 & 8589934592;
  if (D.24711 != 0) goto <D.24712>; else goto <D.24713>;
  <D.24712>:
  outarg_count = outarg_count + 1;
  <D.24713>:
  i = i + 1;
  <D.20669>:
  D.24714 = sig->param_count;
  D.24715 = (int) D.24714;
  if (D.24715 > i) goto <D.20668>; else goto <D.20670>;
  <D.20670>:
  object_array_klass.168 = object_array_klass;
  if (object_array_klass.168 == 0B) goto <D.24717>; else goto <D.24718>;
  <D.24717>:
  {
    struct MonoClass * klass;

    D.24719 = mono_defaults.object_class;
    klass = mono_array_class_get (D.24719, 1);
    D.24720 = klass == 0B;
    D.24721 = (long int) D.24720;
    D.24722 = __builtin_expect (D.24721, 0);
    if (D.24722 != 0) goto <D.24723>; else goto <D.24724>;
    <D.24723>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 6014, "klass");
    <D.24724>:
    mono_memory_barrier ();
    object_array_klass = klass;
  }
  <D.24718>:
  object_array_klass.168 = object_array_klass;
  D.24725 = mono_class_vtable (domain, object_array_klass.168);
  D.24726 = (long unsigned int) outarg_count;
  D.24727 = mono_array_new_specific (D.24725, D.24726);
  *out_args = D.24727;
  *exc = 0B;
  D.24729 = method->klass;
  D.24730 = BIT_FIELD_REF <*D.24729, 64, 256>;
  D.24731 = D.24730 & 1152921504606846976;
  if (D.24731 != 0) goto <D.24732>; else goto <D.24733>;
  <D.24732>:
  iftmp.169 = mono_object_unbox (target);
  goto <D.24734>;
  <D.24733>:
  iftmp.169 = target;
  <D.24734>:
  D.24735 = msg->args;
  ret = mono_runtime_invoke_array (method, iftmp.169, D.24735, exc);
  i = 0;
  j = 0;
  goto <D.20675>;
  <D.20674>:
  D.24709 = sig->params[i];
  D.24710 = BIT_FIELD_REF <*D.24709, 64, 64>;
  D.24711 = D.24710 & 8589934592;
  if (D.24711 != 0) goto <D.24736>; else goto <D.24737>;
  <D.24736>:
  {
    struct MonoObject * arg;

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

      D.24740 = *out_args;
      D.24741 = (long unsigned int) j;
      __p = mono_array_addr_with_size (D.24740, 8, D.24741);
      D.24740 = *out_args;
      mono_gc_wbarrier_set_arrayref (D.24740, __p, arg);
    }
    j = j + 1;
  }
  <D.24737>:
  i = i + 1;
  <D.20675>:
  D.24714 = sig->param_count;
  D.24715 = (int) D.24714;
  if (D.24715 > i) goto <D.20674>; else goto <D.20676>;
  <D.20676>:
  D.24707 = ret;
  return D.24707;
}


mono_object_to_string (struct MonoObject * obj, struct MonoObject * * exc)
{
  _Bool D.24743;
  long int D.24744;
  long int D.24745;
  struct MonoMethod * to_string.170;
  struct MonoClass * D.24751;
  struct MonoMethod * to_string.171;
  struct MonoClass * D.24753;
  int D.24754;
  struct MonoString * D.24757;
  static struct MonoMethod * to_string = 0B;
  struct MonoMethod * method;
  void * target;

  target = obj;
  D.24743 = obj == 0B;
  D.24744 = (long int) D.24743;
  D.24745 = __builtin_expect (D.24744, 0);
  if (D.24745 != 0) goto <D.24746>; else goto <D.24747>;
  <D.24746>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 6052, "obj");
  <D.24747>:
  to_string.170 = to_string;
  if (to_string.170 == 0B) goto <D.24749>; else goto <D.24750>;
  <D.24749>:
  D.24751 = mono_get_object_class ();
  to_string.171 = mono_class_get_method_from_name_flags (D.24751, "ToString", 0, 70);
  to_string = to_string.171;
  <D.24750>:
  to_string.170 = to_string;
  method = mono_object_get_virtual_method (obj, to_string.170);
  D.24753 = mono_method_get_class (method);
  D.24754 = mono_class_is_valuetype (D.24753);
  if (D.24754 != 0) goto <D.24755>; else goto <D.24756>;
  <D.24755>:
  target = mono_object_unbox (obj);
  <D.24756>:
  D.24757 = mono_runtime_invoke (method, target, 0B, exc);
  return D.24757;
}


mono_print_unhandled_exception (struct MonoObject * exc)
{
  struct MonoVTable * D.24759;
  struct MonoDomain * D.24760;
  struct MonoException * D.24761;
  struct MonoArray * D.24765;
  struct MonoObject * other_exc.172;
  int D.24775;
  struct MonoString * str;
  char * message;
  gboolean free_message;
  struct MonoError error;

  try
    {
      message = "";
      free_message = 0;
      D.24759 = exc->vtable;
      D.24760 = D.24759->domain;
      D.24761 = D.24760->out_of_memory_ex;
      if (D.24761 == exc) goto <D.24762>; else goto <D.24763>;
      <D.24762>:
      message = monoeg_strdup ("OutOfMemoryException");
      free_message = 1;
      goto <D.24764>;
      <D.24763>:
      D.24765 = MEM[(struct MonoException *)exc].native_trace_ips;
      if (D.24765 != 0B) goto <D.24766>; else goto <D.24767>;
      <D.24766>:
      message = mono_exception_get_native_backtrace (exc);
      free_message = 1;
      goto <D.24768>;
      <D.24767>:
      {
        struct MonoObject * other_exc;

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

              original_backtrace = mono_exception_get_managed_backtrace (exc);
              other_exc.172 = other_exc;
              nested_backtrace = mono_exception_get_managed_backtrace (other_exc.172);
              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.24772>;
            <D.24771>:
            if (str != 0B) goto <D.24773>; else goto <D.24774>;
            <D.24773>:
            message = mono_string_to_utf8_checked (str, &error);
            D.24775 = mono_error_ok (&error);
            if (D.24775 == 0) goto <D.24776>; else goto <D.24777>;
            <D.24776>:
            mono_error_cleanup (&error);
            message = "";
            goto <D.24778>;
            <D.24777>:
            free_message = 1;
            <D.24778>:
            <D.24774>:
            <D.24772>:
          }
        finally
          {
            other_exc = {CLOBBER};
          }
      }
      <D.24768>:
      <D.24764>:
      monoeg_g_printerr ("\nUnhandled Exception:\n%s\n", message);
      if (free_message != 0) goto <D.24779>; else goto <D.24780>;
      <D.24779>:
      monoeg_g_free (message);
      <D.24780>:
    }
  finally
    {
      error = {CLOBBER};
    }
}


__attribute__((visibility ("hidden")))
mono_delegate_ctor_with_method (struct MonoObject * this, struct MonoObject * target, void * addr, struct MonoMethod * method)
{
  _Bool D.24781;
  long int D.24782;
  long int D.24783;
  _Bool D.24786;
  long int D.24787;
  long int D.24788;
  struct MonoVTable * D.24793;
  long unsigned int D.24794;
  long unsigned int D.24795;
  struct MonoVTable * D.24799;
  struct MonoClass * D.24800;
  struct MonoClass * D.24801;
  _Bool D.24803;
  long int D.24804;
  long int D.24805;
  void * D.24808;
  struct MonoObject * * D.24809;
  void * (*<T1f23>) (struct MonoDomain *, struct MonoClass *) arch_create_delegate_trampoline.173;
  struct MonoVTable * D.24811;
  struct MonoDomain * D.24812;
  struct MonoClass * D.24813;
  void * D.24814;
  struct MonoDelegate * delegate;
  struct MonoClass * class;

  delegate = this;
  D.24781 = this == 0B;
  D.24782 = (long int) D.24781;
  D.24783 = __builtin_expect (D.24782, 0);
  if (D.24783 != 0) goto <D.24784>; else goto <D.24785>;
  <D.24784>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 6142, "this");
  <D.24785>:
  D.24786 = addr == 0B;
  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>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 6143, "addr");
  <D.24790>:
  if (method != 0B) goto <D.24791>; else goto <D.24792>;
  <D.24791>:
  delegate->method = method;
  <D.24792>:
  D.24793 = this->vtable;
  class = D.24793->klass;
  D.24794 = mono_stats.delegate_creations;
  D.24795 = D.24794 + 1;
  mono_stats.delegate_creations = D.24795;
  if (target != 0B) goto <D.24798>; else goto <D.24796>;
  <D.24798>:
  D.24799 = target->vtable;
  D.24800 = D.24799->klass;
  D.24801 = mono_defaults.transparent_proxy_class;
  if (D.24800 == D.24801) goto <D.24802>; else goto <D.24796>;
  <D.24802>:
  D.24803 = method == 0B;
  D.24804 = (long int) D.24803;
  D.24805 = __builtin_expect (D.24804, 0);
  if (D.24805 != 0) goto <D.24806>; else goto <D.24807>;
  <D.24806>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 6153, "method");
  <D.24807>:
  method = mono_marshal_get_remoting_invoke (method);
  D.24808 = mono_compile_method (method);
  delegate->method_ptr = D.24808;
  D.24809 = &delegate->target;
  mono_gc_wbarrier_set_field (delegate, D.24809, target);
  goto <D.24797>;
  <D.24796>:
  delegate->method_ptr = addr;
  D.24809 = &delegate->target;
  mono_gc_wbarrier_set_field (delegate, D.24809, target);
  <D.24797>:
  arch_create_delegate_trampoline.173 = arch_create_delegate_trampoline;
  D.24811 = delegate->object.vtable;
  D.24812 = D.24811->domain;
  D.24811 = delegate->object.vtable;
  D.24813 = D.24811->klass;
  D.24814 = arch_create_delegate_trampoline.173 (D.24812, D.24813);
  delegate->invoke_impl = D.24814;
}


__attribute__((visibility ("hidden")))
mono_delegate_ctor (struct MonoObject * this, struct MonoObject * target, void * addr)
{
  _Bool D.24815;
  long int D.24816;
  long int D.24817;
  void * D.24820;
  struct MonoDomain * D.24823;
  struct MonoDomain * D.24826;
  void * D.24827;
  struct MonoClass * D.24830;
  struct MonoGenericContainer * D.24831;
  _Bool D.24832;
  long int D.24833;
  long int D.24834;
  struct MonoDomain * domain;
  struct MonoJitInfo * ji;
  struct MonoMethod * method;

  domain = mono_domain_get ();
  method = 0B;
  D.24815 = addr == 0B;
  D.24816 = (long int) D.24815;
  D.24817 = __builtin_expect (D.24816, 0);
  if (D.24817 != 0) goto <D.24818>; else goto <D.24819>;
  <D.24818>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 6182, "addr");
  <D.24819>:
  D.24820 = mono_get_addr_from_ftnptr (addr);
  ji = mono_jit_info_table_find (domain, D.24820);
  if (ji == 0B) goto <D.24821>; else goto <D.24822>;
  <D.24821>:
  D.24823 = mono_get_root_domain ();
  if (D.24823 != domain) goto <D.24824>; else goto <D.24825>;
  <D.24824>:
  D.24826 = mono_get_root_domain ();
  D.24827 = mono_get_addr_from_ftnptr (addr);
  ji = mono_jit_info_table_find (D.24826, D.24827);
  <D.24825>:
  <D.24822>:
  if (ji != 0B) goto <D.24828>; else goto <D.24829>;
  <D.24828>:
  method = mono_jit_info_get_method (ji);
  D.24830 = method->klass;
  D.24831 = D.24830->generic_container;
  D.24832 = D.24831 != 0B;
  D.24833 = (long int) D.24832;
  D.24834 = __builtin_expect (D.24833, 0);
  if (D.24834 != 0) goto <D.24835>; else goto <D.24836>;
  <D.24835>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 6190, "!method->klass->generic_container");
  <D.24836>:
  <D.24829>:
  mono_delegate_ctor_with_method (this, target, addr, method);
}


__attribute__((visibility ("hidden")))
mono_method_call_message_new (struct MonoMethod * method, void * * params, struct MonoMethod * invoke, struct MonoDelegate * * cb, struct MonoObject * * state)
{
  struct MonoClass * D.24837;
  struct MonoReflectionMethod * D.24840;
  short unsigned int D.24841;
  int D.24842;
  struct MonoReflectionMethod * D.24844;
  struct MonoType * D.24845;
  long unsigned int D.24846;
  long unsigned int D.24847;
  long unsigned int D.24850;
  long unsigned int D.24851;
  void * * D.24852;
  void * D.24853;
  unsigned char D.24855;
  long unsigned int D.24856;
  long unsigned int D.24857;
  struct MonoArray * D.24861;
  long unsigned int D.24862;
  struct MonoDelegate * D.24867;
  struct MonoObject * D.24868;
  struct MonoMethodMessage * D.24869;
  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.24837 = mono_defaults.mono_method_message_class;
  msg = mono_object_new (domain, D.24837);
  if (invoke != 0B) goto <D.24838>; else goto <D.24839>;
  <D.24838>:
  D.24840 = mono_method_get_object (domain, invoke, 0B);
  mono_message_init (domain, msg, D.24840, 0B);
  D.24841 = sig->param_count;
  D.24842 = (int) D.24841;
  count = D.24842 + -2;
  goto <D.24843>;
  <D.24839>:
  D.24844 = mono_method_get_object (domain, method, 0B);
  mono_message_init (domain, msg, D.24844, 0B);
  D.24841 = sig->param_count;
  count = (int) D.24841;
  <D.24843>:
  i = 0;
  goto <D.20728>;
  <D.20727>:
  {
    void * vpos;
    struct MonoClass * class;
    struct MonoObject * arg;

    D.24845 = sig->params[i];
    D.24846 = BIT_FIELD_REF <*D.24845, 64, 64>;
    D.24847 = D.24846 & 8589934592;
    if (D.24847 != 0) goto <D.24848>; else goto <D.24849>;
    <D.24848>:
    D.24850 = (long unsigned int) i;
    D.24851 = D.24850 * 8;
    D.24852 = params + D.24851;
    D.24853 = *D.24852;
    vpos = MEM[(void * *)D.24853];
    goto <D.24854>;
    <D.24849>:
    D.24850 = (long unsigned int) i;
    D.24851 = D.24850 * 8;
    D.24852 = params + D.24851;
    vpos = *D.24852;
    <D.24854>:
    D.24845 = sig->params[i];
    D.24855 = D.24845->type;
    type = (int) D.24855;
    D.24845 = sig->params[i];
    class = mono_class_from_mono_type (D.24845);
    D.24856 = BIT_FIELD_REF <*class, 64, 256>;
    D.24857 = D.24856 & 1152921504606846976;
    if (D.24857 != 0) goto <D.24858>; else goto <D.24859>;
    <D.24858>:
    arg = mono_value_box (domain, class, vpos);
    goto <D.24860>;
    <D.24859>:
    arg = MEM[(struct MonoObject * *)vpos];
    <D.24860>:
    {
      void * * __p;

      D.24861 = msg->args;
      D.24862 = (long unsigned int) i;
      __p = mono_array_addr_with_size (D.24861, 8, D.24862);
      D.24861 = msg->args;
      mono_gc_wbarrier_set_arrayref (D.24861, __p, arg);
    }
  }
  i = i + 1;
  <D.20728>:
  if (i < count) goto <D.20727>; else goto <D.20729>;
  <D.20729>:
  if (cb != 0B) goto <D.24863>; else goto <D.24864>;
  <D.24863>:
  if (state != 0B) goto <D.24865>; else goto <D.24866>;
  <D.24865>:
  D.24850 = (long unsigned int) i;
  D.24851 = D.24850 * 8;
  D.24852 = params + D.24851;
  D.24853 = *D.24852;
  D.24867 = MEM[(struct MonoDelegate * *)D.24853];
  *cb = D.24867;
  i = i + 1;
  D.24850 = (long unsigned int) i;
  D.24851 = D.24850 * 8;
  D.24852 = params + D.24851;
  D.24853 = *D.24852;
  D.24868 = MEM[(struct MonoObject * *)D.24853];
  *state = D.24868;
  <D.24866>:
  <D.24864>:
  D.24869 = msg;
  return D.24869;
}


__attribute__((visibility ("hidden")))
mono_method_return_message_restore (struct MonoMethod * method, void * * params, struct MonoArray * out_args)
{
  long unsigned int D.24873;
  long unsigned int D.24876;
  long unsigned int D.24877;
  struct MonoException * D.24882;
  long unsigned int D.24883;
  char * D.24884;
  unsigned char D.24885;
  _Bool D.24886;
  long int D.24887;
  long int D.24888;
  int D.24891;
  long unsigned int D.24894;
  long unsigned int D.24895;
  void * * D.24896;
  void * D.24897;
  struct MonoObject * * D.24898;
  struct MonoVTable * D.24902;
  long unsigned int D.24903;
  long unsigned int D.24904;
  void * D.24907;
  char * D.24908;
  long unsigned int D.24910;
  struct MonoClass * D.24912;
  short unsigned int D.24913;
  int D.24914;
  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.24871>; else goto <D.24872>;
  <D.24871>:
  return;
  <D.24872>:
  D.24873 = mono_array_length (out_args);
  out_len = (int) D.24873;
  if (out_len == 0) goto <D.24874>; else goto <D.24875>;
  <D.24874>:
  return;
  <D.24875>:
  i = 0;
  j = 0;
  goto <D.20745>;
  <D.20744>:
  {
    struct MonoType * pt;

    pt = sig->params[i];
    D.24876 = BIT_FIELD_REF <*pt, 64, 64>;
    D.24877 = D.24876 & 8589934592;
    if (D.24877 != 0) goto <D.24878>; else goto <D.24879>;
    <D.24878>:
    {
      char * arg;

      if (j >= out_len) goto <D.24880>; else goto <D.24881>;
      <D.24880>:
      D.24882 = mono_get_exception_execution_engine ("The proxy call returned an incorrect number of output arguments");
      mono_raise_exception (D.24882);
      <D.24881>:
      D.24883 = (long unsigned int) j;
      D.24884 = mono_array_addr_with_size (out_args, 8, D.24883);
      arg = MEM[(void * *)D.24884];
      D.24885 = pt->type;
      type = (int) D.24885;
      D.24886 = type == 1;
      D.24887 = (long int) D.24886;
      D.24888 = __builtin_expect (D.24887, 0);
      if (D.24888 != 0) goto <D.24889>; else goto <D.24890>;
      <D.24889>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 6283, "type != MONO_TYPE_VOID");
      <D.24890>:
      D.24891 = mono_type_is_reference (pt);
      if (D.24891 != 0) goto <D.24892>; else goto <D.24893>;
      <D.24892>:
      D.24894 = (long unsigned int) i;
      D.24895 = D.24894 * 8;
      D.24896 = params + D.24895;
      D.24897 = *D.24896;
      D.24898 = MEM[(struct MonoObject * * *)D.24897];
      mono_gc_wbarrier_generic_store (D.24898, arg);
      goto <D.24899>;
      <D.24893>:
      if (arg != 0B) goto <D.24900>; else goto <D.24901>;
      <D.24900>:
      {
        struct MonoClass * class;

        D.24902 = MEM[(struct MonoObject *)arg].vtable;
        class = D.24902->klass;
        size = mono_class_value_size (class, 0B);
        D.24903 = BIT_FIELD_REF <*class, 64, 256>;
        D.24904 = D.24903 & 68719476736;
        if (D.24904 != 0) goto <D.24905>; else goto <D.24906>;
        <D.24905>:
        D.24894 = (long unsigned int) i;
        D.24895 = D.24894 * 8;
        D.24896 = params + D.24895;
        D.24897 = *D.24896;
        D.24907 = MEM[(void * *)D.24897];
        D.24908 = arg + 16;
        mono_gc_wbarrier_value_copy (D.24907, D.24908, 1, class);
        goto <D.24909>;
        <D.24906>:
        D.24894 = (long unsigned int) i;
        D.24895 = D.24894 * 8;
        D.24896 = params + D.24895;
        D.24897 = *D.24896;
        D.24907 = MEM[(void * *)D.24897];
        D.24908 = arg + 16;
        D.24910 = (long unsigned int) size;
        mono_gc_memmove_atomic (D.24907, D.24908, D.24910);
        <D.24909>:
      }
      goto <D.24911>;
      <D.24901>:
      D.24912 = mono_class_from_mono_type (pt);
      size = mono_class_value_size (D.24912, 0B);
      D.24894 = (long unsigned int) i;
      D.24895 = D.24894 * 8;
      D.24896 = params + D.24895;
      D.24897 = *D.24896;
      D.24907 = MEM[(void * *)D.24897];
      D.24910 = (long unsigned int) size;
      mono_gc_bzero_atomic (D.24907, D.24910);
      <D.24911>:
      <D.24899>:
      j = j + 1;
    }
    <D.24879>:
  }
  i = i + 1;
  <D.20745>:
  D.24913 = sig->param_count;
  D.24914 = (int) D.24913;
  if (D.24914 > i) goto <D.20744>; else goto <D.20746>;
  <D.20746>:
}


mono_load_remote_field (struct MonoObject * this, struct MonoClass * klass, struct MonoClassField * field, void * * res)
{
  struct MonoVTable * D.24916;
  struct MonoClass * D.24917;
  struct MonoClass * D.24918;
  _Bool D.24919;
  long int D.24920;
  long int D.24921;
  _Bool D.24924;
  long int D.24925;
  long int D.24926;
  struct MonoRemoteClass * D.24929;
  struct MonoClass * D.24930;
  long unsigned int D.24931;
  long unsigned int D.24932;
  struct MonoRealProxy * D.24935;
  struct MonoObject * D.24936;
  struct MonoAppContext * D.24937;
  struct MonoObject * D.24940;
  void * D.24941;
  struct MonoMethod * getter.174;
  struct MonoClass * D.24945;
  struct MonoMethod * getter.175;
  _Bool D.24947;
  long int D.24948;
  long int D.24949;
  struct MonoType * D.24952;
  struct MonoClass * D.24953;
  struct MonoArray * out_args.176;
  struct MonoReflectionMethod * D.24955;
  struct MonoArray * out_args.177;
  struct MonoArray * D.24957;
  struct MonoString * D.24958;
  const char * D.24959;
  struct MonoString * D.24960;
  struct MonoObject * exc.178;
  long unsigned int D.24964;
  char * D.24967;
  struct MonoObject * D.24968;
  long unsigned int D.24969;
  long unsigned int D.24970;
  void * D.24973;
  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.24916 = this->vtable;
      D.24917 = D.24916->klass;
      D.24918 = mono_defaults.transparent_proxy_class;
      D.24919 = D.24917 != D.24918;
      D.24920 = (long int) D.24919;
      D.24921 = __builtin_expect (D.24920, 0);
      if (D.24921 != 0) goto <D.24922>; else goto <D.24923>;
      <D.24922>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 6334, "mono_object_is_transparent_proxy (this)");
      <D.24923>:
      D.24924 = res == 0B;
      D.24925 = (long int) D.24924;
      D.24926 = __builtin_expect (D.24925, 0);
      if (D.24926 != 0) goto <D.24927>; else goto <D.24928>;
      <D.24927>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 6335, "res != NULL");
      <D.24928>:
      D.24929 = tp->remote_class;
      D.24930 = D.24929->proxy_class;
      D.24931 = BIT_FIELD_REF <*D.24930, 64, 256>;
      D.24932 = D.24931 & 1099511627776;
      if (D.24932 != 0) goto <D.24933>; else goto <D.24934>;
      <D.24933>:
      D.24935 = tp->rp;
      D.24936 = D.24935->context;
      D.24937 = mono_context_get ();
      if (D.24936 == D.24937) goto <D.24938>; else goto <D.24939>;
      <D.24938>:
      D.24935 = tp->rp;
      D.24940 = D.24935->unwrapped_server;
      mono_field_get_value (D.24940, field, res);
      D.24941 = res;
      return D.24941;
      <D.24939>:
      <D.24934>:
      getter.174 = getter;
      if (getter.174 == 0B) goto <D.24943>; else goto <D.24944>;
      <D.24943>:
      D.24945 = mono_defaults.object_class;
      getter.175 = mono_class_get_method_from_name (D.24945, "FieldGetter", -1);
      getter = getter.175;
      getter.174 = getter;
      D.24947 = getter.174 == 0B;
      D.24948 = (long int) D.24947;
      D.24949 = __builtin_expect (D.24948, 0);
      if (D.24949 != 0) goto <D.24950>; else goto <D.24951>;
      <D.24950>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 6344, "getter");
      <D.24951>:
      <D.24944>:
      D.24952 = field->type;
      field_class = mono_class_from_mono_type (D.24952);
      D.24953 = mono_defaults.mono_method_message_class;
      msg = mono_object_new (domain, D.24953);
      D.24945 = mono_defaults.object_class;
      out_args.176 = mono_array_new (domain, D.24945, 1);
      out_args = out_args.176;
      getter.174 = getter;
      D.24955 = mono_method_get_object (domain, getter.174, 0B);
      out_args.177 = out_args;
      mono_message_init (domain, msg, D.24955, out_args.177);
      full_name = mono_type_get_full_name (klass);
      {
        void * * __p;

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

        D.24957 = msg->args;
        __p = mono_array_addr_with_size (D.24957, 8, 1);
        D.24957 = msg->args;
        D.24959 = mono_field_get_name (field);
        D.24960 = mono_string_new (domain, D.24959);
        mono_gc_wbarrier_set_arrayref (D.24957, __p, D.24960);
      }
      monoeg_g_free (full_name);
      D.24935 = tp->rp;
      mono_remoting_invoke (D.24935, msg, &exc, &out_args);
      exc.178 = exc;
      if (exc.178 != 0B) goto <D.24962>; else goto <D.24963>;
      <D.24962>:
      exc.178 = exc;
      mono_raise_exception (exc.178);
      <D.24963>:
      out_args.177 = out_args;
      D.24964 = mono_array_length (out_args.177);
      if (D.24964 == 0) goto <D.24965>; else goto <D.24966>;
      <D.24965>:
      D.24941 = 0B;
      return D.24941;
      <D.24966>:
      out_args.177 = out_args;
      D.24967 = mono_array_addr_with_size (out_args.177, 8, 0);
      D.24968 = MEM[(struct MonoObject * *)D.24967];
      *res = D.24968;
      D.24969 = BIT_FIELD_REF <*field_class, 64, 256>;
      D.24970 = D.24969 & 1152921504606846976;
      if (D.24970 != 0) goto <D.24971>; else goto <D.24972>;
      <D.24971>:
      D.24973 = *res;
      D.24941 = D.24973 + 16;
      return D.24941;
      <D.24972>:
      D.24941 = res;
      return D.24941;
    }
  finally
    {
      out_args = {CLOBBER};
      exc = {CLOBBER};
    }
}


mono_load_remote_field_new (struct MonoObject * this, struct MonoClass * klass, struct MonoClassField * field)
{
  struct MonoVTable * D.24976;
  struct MonoClass * D.24977;
  struct MonoClass * D.24978;
  _Bool D.24979;
  long int D.24980;
  long int D.24981;
  struct MonoType * D.24984;
  struct MonoRemoteClass * D.24985;
  struct MonoClass * D.24986;
  long unsigned int D.24987;
  long unsigned int D.24988;
  struct MonoRealProxy * D.24991;
  struct MonoObject * D.24992;
  struct MonoAppContext * D.24993;
  long unsigned int D.24996;
  long unsigned int D.24997;
  struct MonoObject * res.179;
  struct MonoObject * res.180;
  struct MonoObject * D.25003;
  struct MonoObject * D.25004;
  struct MonoMethod * getter.181;
  struct MonoClass * D.25008;
  struct MonoMethod * getter.182;
  _Bool D.25010;
  long int D.25011;
  long int D.25012;
  struct MonoClass * D.25015;
  struct MonoArray * out_args.183;
  struct MonoReflectionMethod * D.25017;
  struct MonoArray * out_args.184;
  struct MonoArray * D.25019;
  struct MonoString * D.25020;
  const char * D.25021;
  struct MonoString * D.25022;
  struct MonoObject * exc.185;
  long unsigned int D.25026;
  char * D.25030;
  struct MonoObject * res.186;
  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.24976 = this->vtable;
      D.24977 = D.24976->klass;
      D.24978 = mono_defaults.transparent_proxy_class;
      D.24979 = D.24977 != D.24978;
      D.24980 = (long int) D.24979;
      D.24981 = __builtin_expect (D.24980, 0);
      if (D.24981 != 0) goto <D.24982>; else goto <D.24983>;
      <D.24982>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 6393, "mono_object_is_transparent_proxy (this)");
      <D.24983>:
      D.24984 = field->type;
      field_class = mono_class_from_mono_type (D.24984);
      D.24985 = tp->remote_class;
      D.24986 = D.24985->proxy_class;
      D.24987 = BIT_FIELD_REF <*D.24986, 64, 256>;
      D.24988 = D.24987 & 1099511627776;
      if (D.24988 != 0) goto <D.24989>; else goto <D.24990>;
      <D.24989>:
      D.24991 = tp->rp;
      D.24992 = D.24991->context;
      D.24993 = mono_context_get ();
      if (D.24992 == D.24993) goto <D.24994>; else goto <D.24995>;
      <D.24994>:
      {
        void * val;

        D.24996 = BIT_FIELD_REF <*field_class, 64, 256>;
        D.24997 = D.24996 & 1152921504606846976;
        if (D.24997 != 0) goto <D.24998>; else goto <D.24999>;
        <D.24998>:
        res.179 = mono_object_new (domain, field_class);
        res = res.179;
        res.180 = res;
        val = res.180 + 16;
        goto <D.25002>;
        <D.24999>:
        val = &res;
        <D.25002>:
        D.24991 = tp->rp;
        D.25003 = D.24991->unwrapped_server;
        mono_field_get_value (D.25003, field, val);
        D.25004 = res;
        return D.25004;
      }
      <D.24995>:
      <D.24990>:
      getter.181 = getter;
      if (getter.181 == 0B) goto <D.25006>; else goto <D.25007>;
      <D.25006>:
      D.25008 = mono_defaults.object_class;
      getter.182 = mono_class_get_method_from_name (D.25008, "FieldGetter", -1);
      getter = getter.182;
      getter.181 = getter;
      D.25010 = getter.181 == 0B;
      D.25011 = (long int) D.25010;
      D.25012 = __builtin_expect (D.25011, 0);
      if (D.25012 != 0) goto <D.25013>; else goto <D.25014>;
      <D.25013>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 6411, "getter");
      <D.25014>:
      <D.25007>:
      D.25015 = mono_defaults.mono_method_message_class;
      msg = mono_object_new (domain, D.25015);
      D.25008 = mono_defaults.object_class;
      out_args.183 = mono_array_new (domain, D.25008, 1);
      out_args = out_args.183;
      getter.181 = getter;
      D.25017 = mono_method_get_object (domain, getter.181, 0B);
      out_args.184 = out_args;
      mono_message_init (domain, msg, D.25017, out_args.184);
      full_name = mono_type_get_full_name (klass);
      {
        void * * __p;

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

        D.25019 = msg->args;
        __p = mono_array_addr_with_size (D.25019, 8, 1);
        D.25019 = msg->args;
        D.25021 = mono_field_get_name (field);
        D.25022 = mono_string_new (domain, D.25021);
        mono_gc_wbarrier_set_arrayref (D.25019, __p, D.25022);
      }
      monoeg_g_free (full_name);
      D.24991 = tp->rp;
      mono_remoting_invoke (D.24991, msg, &exc, &out_args);
      exc.185 = exc;
      if (exc.185 != 0B) goto <D.25024>; else goto <D.25025>;
      <D.25024>:
      exc.185 = exc;
      mono_raise_exception (exc.185);
      <D.25025>:
      out_args.184 = out_args;
      D.25026 = mono_array_length (out_args.184);
      if (D.25026 == 0) goto <D.25027>; else goto <D.25028>;
      <D.25027>:
      res = 0B;
      goto <D.25029>;
      <D.25028>:
      out_args.184 = out_args;
      D.25030 = mono_array_addr_with_size (out_args.184, 8, 0);
      res.186 = MEM[(struct MonoObject * *)D.25030];
      res = res.186;
      <D.25029>:
      D.25004 = res;
      return D.25004;
    }
  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.25034;
  struct MonoClass * D.25035;
  struct MonoClass * D.25036;
  _Bool D.25037;
  long int D.25038;
  long int D.25039;
  struct MonoType * D.25042;
  struct MonoRemoteClass * D.25043;
  struct MonoClass * D.25044;
  long unsigned int D.25045;
  long unsigned int D.25046;
  struct MonoRealProxy * D.25049;
  struct MonoObject * D.25050;
  struct MonoAppContext * D.25051;
  long unsigned int D.25054;
  long unsigned int D.25055;
  struct MonoObject * D.25058;
  struct MonoObject * D.25060;
  struct MonoMethod * setter.187;
  struct MonoClass * D.25064;
  struct MonoMethod * setter.188;
  _Bool D.25066;
  long int D.25067;
  long int D.25068;
  struct MonoClass * D.25074;
  struct MonoReflectionMethod * D.25075;
  struct MonoArray * D.25076;
  struct MonoString * D.25077;
  const char * D.25078;
  struct MonoString * D.25079;
  struct MonoObject * exc.189;
  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.25034 = this->vtable;
      D.25035 = D.25034->klass;
      D.25036 = mono_defaults.transparent_proxy_class;
      D.25037 = D.25035 != D.25036;
      D.25038 = (long int) D.25037;
      D.25039 = __builtin_expect (D.25038, 0);
      if (D.25039 != 0) goto <D.25040>; else goto <D.25041>;
      <D.25040>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 6460, "mono_object_is_transparent_proxy (this)");
      <D.25041>:
      D.25042 = field->type;
      field_class = mono_class_from_mono_type (D.25042);
      D.25043 = tp->remote_class;
      D.25044 = D.25043->proxy_class;
      D.25045 = BIT_FIELD_REF <*D.25044, 64, 256>;
      D.25046 = D.25045 & 1099511627776;
      if (D.25046 != 0) goto <D.25047>; else goto <D.25048>;
      <D.25047>:
      D.25049 = tp->rp;
      D.25050 = D.25049->context;
      D.25051 = mono_context_get ();
      if (D.25050 == D.25051) goto <D.25052>; else goto <D.25053>;
      <D.25052>:
      D.25054 = BIT_FIELD_REF <*field_class, 64, 256>;
      D.25055 = D.25054 & 1152921504606846976;
      if (D.25055 != 0) goto <D.25056>; else goto <D.25057>;
      <D.25056>:
      D.25049 = tp->rp;
      D.25058 = D.25049->unwrapped_server;
      mono_field_set_value (D.25058, field, val);
      goto <D.25059>;
      <D.25057>:
      D.25049 = tp->rp;
      D.25058 = D.25049->unwrapped_server;
      D.25060 = MEM[(struct MonoObject * *)val];
      mono_field_set_value (D.25058, field, D.25060);
      <D.25059>:
      return;
      <D.25053>:
      <D.25048>:
      setter.187 = setter;
      if (setter.187 == 0B) goto <D.25062>; else goto <D.25063>;
      <D.25062>:
      D.25064 = mono_defaults.object_class;
      setter.188 = mono_class_get_method_from_name (D.25064, "FieldSetter", -1);
      setter = setter.188;
      setter.187 = setter;
      D.25066 = setter.187 == 0B;
      D.25067 = (long int) D.25066;
      D.25068 = __builtin_expect (D.25067, 0);
      if (D.25068 != 0) goto <D.25069>; else goto <D.25070>;
      <D.25069>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 6472, "setter");
      <D.25070>:
      <D.25063>:
      D.25054 = BIT_FIELD_REF <*field_class, 64, 256>;
      D.25055 = D.25054 & 1152921504606846976;
      if (D.25055 != 0) goto <D.25071>; else goto <D.25072>;
      <D.25071>:
      arg = mono_value_box (domain, field_class, val);
      goto <D.25073>;
      <D.25072>:
      arg = MEM[(struct MonoObject * *)val];
      <D.25073>:
      D.25074 = mono_defaults.mono_method_message_class;
      msg = mono_object_new (domain, D.25074);
      setter.187 = setter;
      D.25075 = mono_method_get_object (domain, setter.187, 0B);
      mono_message_init (domain, msg, D.25075, 0B);
      full_name = mono_type_get_full_name (klass);
      {
        void * * __p;

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

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

        D.25076 = msg->args;
        __p = mono_array_addr_with_size (D.25076, 8, 2);
        D.25076 = msg->args;
        mono_gc_wbarrier_set_arrayref (D.25076, __p, arg);
      }
      monoeg_g_free (full_name);
      D.25049 = tp->rp;
      mono_remoting_invoke (D.25049, msg, &exc, &out_args);
      exc.189 = exc;
      if (exc.189 != 0B) goto <D.25081>; else goto <D.25082>;
      <D.25081>:
      exc.189 = exc;
      mono_raise_exception (exc.189);
      <D.25082>:
    }
  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.25086;
  struct MonoClass * D.25087;
  struct MonoClass * D.25088;
  _Bool D.25089;
  long int D.25090;
  long int D.25091;
  struct MonoType * D.25094;
  struct MonoRemoteClass * D.25095;
  struct MonoClass * D.25096;
  long unsigned int D.25097;
  long unsigned int D.25098;
  struct MonoRealProxy * D.25101;
  struct MonoObject * D.25102;
  struct MonoAppContext * D.25103;
  long unsigned int D.25106;
  long unsigned int D.25107;
  struct MonoObject * D.25110;
  void * D.25111;
  struct MonoMethod * setter.190;
  struct MonoClass * D.25116;
  struct MonoMethod * setter.191;
  _Bool D.25118;
  long int D.25119;
  long int D.25120;
  struct MonoClass * D.25123;
  struct MonoReflectionMethod * D.25124;
  struct MonoArray * D.25125;
  struct MonoString * D.25126;
  const char * D.25127;
  struct MonoString * D.25128;
  struct MonoObject * exc.192;
  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.25086 = this->vtable;
      D.25087 = D.25086->klass;
      D.25088 = mono_defaults.transparent_proxy_class;
      D.25089 = D.25087 != D.25088;
      D.25090 = (long int) D.25089;
      D.25091 = __builtin_expect (D.25090, 0);
      if (D.25091 != 0) goto <D.25092>; else goto <D.25093>;
      <D.25092>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 6516, "mono_object_is_transparent_proxy (this)");
      <D.25093>:
      D.25094 = field->type;
      field_class = mono_class_from_mono_type (D.25094);
      D.25095 = tp->remote_class;
      D.25096 = D.25095->proxy_class;
      D.25097 = BIT_FIELD_REF <*D.25096, 64, 256>;
      D.25098 = D.25097 & 1099511627776;
      if (D.25098 != 0) goto <D.25099>; else goto <D.25100>;
      <D.25099>:
      D.25101 = tp->rp;
      D.25102 = D.25101->context;
      D.25103 = mono_context_get ();
      if (D.25102 == D.25103) goto <D.25104>; else goto <D.25105>;
      <D.25104>:
      D.25106 = BIT_FIELD_REF <*field_class, 64, 256>;
      D.25107 = D.25106 & 1152921504606846976;
      if (D.25107 != 0) goto <D.25108>; else goto <D.25109>;
      <D.25108>:
      D.25101 = tp->rp;
      D.25110 = D.25101->unwrapped_server;
      D.25111 = arg + 16;
      mono_field_set_value (D.25110, field, D.25111);
      goto <D.25112>;
      <D.25109>:
      D.25101 = tp->rp;
      D.25110 = D.25101->unwrapped_server;
      mono_field_set_value (D.25110, field, arg);
      <D.25112>:
      return;
      <D.25105>:
      <D.25100>:
      setter.190 = setter;
      if (setter.190 == 0B) goto <D.25114>; else goto <D.25115>;
      <D.25114>:
      D.25116 = mono_defaults.object_class;
      setter.191 = mono_class_get_method_from_name (D.25116, "FieldSetter", -1);
      setter = setter.191;
      setter.190 = setter;
      D.25118 = setter.190 == 0B;
      D.25119 = (long int) D.25118;
      D.25120 = __builtin_expect (D.25119, 0);
      if (D.25120 != 0) goto <D.25121>; else goto <D.25122>;
      <D.25121>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 6528, "setter");
      <D.25122>:
      <D.25115>:
      D.25123 = mono_defaults.mono_method_message_class;
      msg = mono_object_new (domain, D.25123);
      setter.190 = setter;
      D.25124 = mono_method_get_object (domain, setter.190, 0B);
      mono_message_init (domain, msg, D.25124, 0B);
      full_name = mono_type_get_full_name (klass);
      {
        void * * __p;

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

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

        D.25125 = msg->args;
        __p = mono_array_addr_with_size (D.25125, 8, 2);
        D.25125 = msg->args;
        mono_gc_wbarrier_set_arrayref (D.25125, __p, arg);
      }
      monoeg_g_free (full_name);
      D.25101 = tp->rp;
      mono_remoting_invoke (D.25101, msg, &exc, &out_args);
      exc.192 = exc;
      if (exc.192 != 0B) goto <D.25130>; else goto <D.25131>;
      <D.25130>:
      exc.192 = exc;
      mono_raise_exception (exc.192);
      <D.25131>:
    }
  finally
    {
      out_args = {CLOBBER};
      exc = {CLOBBER};
    }
}


__attribute__((visibility ("hidden")))
mono_create_ftnptr (struct MonoDomain * domain, void * addr)
{
  void * D.25135;
  void * (*<T268d>) (struct MonoDomain *, void *) D.25136;

  D.25136 = callbacks.create_ftnptr;
  D.25135 = D.25136 (domain, addr);
  return D.25135;
}


__attribute__((visibility ("hidden")))
mono_get_addr_from_ftnptr (void * descr)
{
  void * D.25138;
  void * (*<T1614>) (void *) D.25139;

  D.25139 = callbacks.get_addr_from_ftnptr;
  D.25138 = D.25139 (descr);
  return D.25138;
}


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

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


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

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


mono_array_length (struct MonoArray * array)
{
  uintptr_t D.25145;
  unsigned int D.25146;

  D.25146 = array->max_length;
  D.25145 = (uintptr_t) D.25146;
  return D.25145;
}


mono_array_addr_with_size (struct MonoArray * array, int size, uintptr_t idx)
{
  char * D.25148;
  double[0:] * D.25149;
  long unsigned int D.25150;
  long unsigned int D.25151;

  D.25149 = &array->vector;
  D.25150 = (long unsigned int) size;
  D.25151 = D.25150 * idx;
  D.25148 = D.25149 + D.25151;
  return D.25148;
}