mono_runtime_object_init (struct MonoObject * this)
{
  struct MonoVTable * D.20769;
  char * D.20772;
  struct MonoClass * D.20773;
  unsigned char D.20774;
  unsigned char D.20775;
  struct MonoMethod * method;
  struct MonoClass * klass;

  method = 0B;
  D.20769 = this->vtable;
  klass = D.20769->klass;
  method = mono_class_get_method_from_name (klass, ".ctor", 0);
  if (method == 0B) goto <D.20770>; else goto <D.20771>;
  <D.20770>:
  D.20772 = mono_type_get_full_name (klass);
  monoeg_g_log (0B, 4, "Could not lookup zero argument constructor for class %s", D.20772);
  <D.18951>:
  goto <D.18951>;
  <D.20771>:
  D.20773 = method->klass;
  D.20774 = BIT_FIELD_REF <*D.20773, 8, 256>;
  D.20775 = D.20774 & 8;
  if (D.20775 != 0) goto <D.20776>; else goto <D.20777>;
  <D.20776>:
  this = mono_object_unbox (this);
  <D.20777>:
  mono_runtime_invoke (method, this, 0B, 0B);
}


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

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


mono_thread_get_main ()
{
  struct MonoThread * D.20784;

  D.20784 = main_thread;
  return D.20784;
}


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

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


mono_type_initialization_cleanup ()
{
  struct GHashTable * blocked_thread_hash.3;

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


free_main_args ()
{
  char * * main_args.4;
  long unsigned int D.20790;
  long unsigned int D.20791;
  char * * D.20792;
  char * D.20793;
  int num_main_args.5;
  int i;

  i = 0;
  goto <D.19984>;
  <D.19983>:
  main_args.4 = main_args;
  D.20790 = (long unsigned int) i;
  D.20791 = D.20790 * 8;
  D.20792 = main_args.4 + D.20791;
  D.20793 = *D.20792;
  monoeg_g_free (D.20793);
  i = i + 1;
  <D.19984>:
  num_main_args.5 = num_main_args;
  if (i < num_main_args.5) goto <D.19983>; else goto <D.19985>;
  <D.19985>:
  main_args.4 = main_args;
  monoeg_g_free (main_args.4);
}


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


mono_runtime_class_init_full (struct MonoVTable * vtable, gboolean raise_exception)
{
  unsigned char D.20795;
  unsigned char D.20796;
  struct MonoException * D.20799;
  struct MonoImage * D.20800;
  unsigned char D.20801;
  unsigned char D.20802;
  unsigned char D.20805;
  struct MonoDomain * D.20808;
  struct MonoException * exc.6;
  struct MonoException * exc.7;
  long unsigned int D.20817;
  _Bool D.20820;
  long int D.20821;
  long int D.20822;
  _Bool D.20829;
  long int D.20830;
  long int D.20831;
  unsigned char D.20834;
  _Bool D.20839;
  long int D.20840;
  long int D.20841;
  struct MonoException * D.20846;
  struct GHashTable * type_initialization_hash.8;
  struct MonoDomain * D.20850;
  int D.20853;
  _Bool D.20858;
  long int D.20859;
  long int D.20860;
  struct MonoException * D.20865;
  struct CRITICAL_SECTION * D.20866;
  union mono_mutex_t * D.20867;
  _Bool D.20870;
  long int D.20871;
  long int D.20872;
  unsigned int D.20878;
  int D.20880;
  _Bool D.20883;
  long int D.20884;
  long int D.20885;
  long unsigned int D.20888;
  unsigned int D.20889;
  int D.20892;
  _Bool D.20896;
  long int D.20897;
  long int D.20898;
  long unsigned int D.20901;
  struct GHashTable * blocked_thread_hash.9;
  unsigned int D.20903;
  unsigned int D.20904;
  long unsigned int D.20905;
  void * D.20906;
  _Bool D.20909;
  long int D.20910;
  long int D.20911;
  struct MonoImage * D.20920;
  int D.19026;
  int iftmp.10;
  int D.19025;
  const char[7] * D.20925;
  unsigned char D.20926;
  int D.20927;
  unsigned char D.20928;
  int D.20929;
  _Bool D.20930;
  _Bool D.20931;
  _Bool D.20932;
  const unsigned char * D.20935;
  unsigned char D.20936;
  int D.20937;
  const unsigned char * D.20938;
  unsigned char D.20939;
  int D.20940;
  _Bool D.20941;
  _Bool D.20942;
  const unsigned char * D.20945;
  unsigned char D.20946;
  int D.20947;
  const unsigned char * D.20948;
  unsigned char D.20949;
  int D.20950;
  _Bool D.20951;
  _Bool D.20952;
  const unsigned char * D.20955;
  unsigned char D.20956;
  int D.20957;
  const unsigned char * D.20958;
  unsigned char D.20959;
  int D.20960;
  const char * D.20962;
  int D.19035;
  int iftmp.11;
  int D.19034;
  const char[28] * D.20967;
  unsigned char D.20968;
  int D.20969;
  unsigned char D.20970;
  int D.20971;
  _Bool D.20972;
  _Bool D.20973;
  _Bool D.20974;
  const unsigned char * D.20977;
  unsigned char D.20978;
  int D.20979;
  const unsigned char * D.20980;
  unsigned char D.20981;
  int D.20982;
  _Bool D.20983;
  _Bool D.20984;
  const unsigned char * D.20987;
  unsigned char D.20988;
  int D.20989;
  const unsigned char * D.20990;
  unsigned char D.20991;
  int D.20992;
  _Bool D.20993;
  _Bool D.20994;
  const unsigned char * D.20997;
  unsigned char D.20998;
  int D.20999;
  const unsigned char * D.21000;
  unsigned char D.21001;
  int D.21002;
  const char * D.21004;
  char D.21008;
  union mono_mutex_t * D.21010;
  _Bool D.21013;
  long int D.21014;
  long int D.21015;
  struct MonoGHashTable * D.21018;
  struct MonoGHashTable * D.21021;
  _Bool D.21024;
  long int D.21025;
  long int D.21026;
  _Bool D.21033;
  long int D.21034;
  long int D.21035;
  _Bool D.21041;
  long int D.21042;
  long int D.21043;
  _Bool D.21048;
  long int D.21049;
  long int D.21050;
  _Bool D.21055;
  long int D.21056;
  long int D.21057;
  const void * D.21062;
  unsigned int D.21063;
  _Bool D.21070;
  long int D.21071;
  long int D.21072;
  struct MonoException * D.21079;
  struct MonoException * exc;
  struct MonoException * exc_to_throw;
  struct MonoMethod * method;
  struct MonoClass * klass;
  gchar * full_name;

  try
    {
      method = 0B;
      D.20795 = BIT_FIELD_REF <*vtable, 8, 344>;
      D.20796 = D.20795 & 2;
      if (D.20796 != 0) goto <D.20797>; else goto <D.20798>;
      <D.20797>:
      D.20799 = 0B;
      return D.20799;
      <D.20798>:
      exc = 0B;
      klass = vtable->klass;
      D.20800 = klass->image;
      D.20801 = BIT_FIELD_REF <*D.20800, 8, 224>;
      D.20802 = D.20801 & 64;
      if (D.20802 == 0) goto <D.20803>; else goto <D.20804>;
      <D.20803>:
      D.20800 = klass->image;
      mono_image_check_for_module_cctor (D.20800);
      D.20800 = klass->image;
      D.20801 = BIT_FIELD_REF <*D.20800, 8, 224>;
      D.20805 = D.20801 & 128;
      if (D.20805 != 0) goto <D.20806>; else goto <D.20807>;
      <D.20806>:
      {
        struct MonoClass * module_klass;
        struct MonoVTable * module_vtable;

        D.20800 = klass->image;
        module_klass = mono_class_get (D.20800, 33554433);
        D.20808 = vtable->domain;
        module_vtable = mono_class_vtable_full (D.20808, module_klass, raise_exception);
        if (module_vtable == 0B) goto <D.20809>; else goto <D.20810>;
        <D.20809>:
        D.20799 = 0B;
        return D.20799;
        <D.20810>:
        exc.6 = mono_runtime_class_init_full (module_vtable, raise_exception);
        exc = exc.6;
        exc.7 = exc;
        if (exc.7 != 0B) goto <D.20813>; else goto <D.20814>;
        <D.20813>:
        D.20799 = exc;
        return D.20799;
        <D.20814>:
      }
      <D.20807>:
      <D.20804>:
      method = mono_class_get_cctor (klass);
      if (method != 0B) goto <D.20815>; else goto <D.20816>;
      <D.20815>:
      {
        struct MonoDomain * domain;
        struct TypeInitializationLock * lock;
        guint32 tid;
        int do_initialization;
        struct MonoDomain * last_domain;

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

          ret = pthread_mutex_lock (&type_initialization_section.mutex);
          if (ret != 0) goto <D.20818>; else goto <D.20819>;
          <D.20818>:
          monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
          <D.20819>:
          D.20820 = ret != 0;
          D.20821 = (long int) D.20820;
          D.20822 = __builtin_expect (D.20821, 0);
          if (D.20822 != 0) goto <D.20823>; else goto <D.20824>;
          <D.20823>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 308, "ret == 0");
          <D.20824>:
        }
        D.20795 = BIT_FIELD_REF <*vtable, 8, 344>;
        D.20796 = D.20795 & 2;
        if (D.20796 != 0) goto <D.20825>; else goto <D.20826>;
        <D.20825>:
        {
          int ret;

          ret = pthread_mutex_unlock (&type_initialization_section.mutex);
          if (ret != 0) goto <D.20827>; else goto <D.20828>;
          <D.20827>:
          monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
          <D.20828>:
          D.20829 = ret != 0;
          D.20830 = (long int) D.20829;
          D.20831 = __builtin_expect (D.20830, 0);
          if (D.20831 != 0) goto <D.20832>; else goto <D.20833>;
          <D.20832>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 311, "ret == 0");
          <D.20833>:
        }
        D.20799 = 0B;
        return D.20799;
        <D.20826>:
        D.20795 = BIT_FIELD_REF <*vtable, 8, 344>;
        D.20834 = D.20795 & 4;
        if (D.20834 != 0) goto <D.20835>; else goto <D.20836>;
        <D.20835>:
        {
          int ret;

          ret = pthread_mutex_unlock (&type_initialization_section.mutex);
          if (ret != 0) goto <D.20837>; else goto <D.20838>;
          <D.20837>:
          monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
          <D.20838>:
          D.20839 = ret != 0;
          D.20840 = (long int) D.20839;
          D.20841 = __builtin_expect (D.20840, 0);
          if (D.20841 != 0) goto <D.20842>; else goto <D.20843>;
          <D.20842>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 315, "ret == 0");
          <D.20843>:
        }
        if (raise_exception != 0) goto <D.20844>; else goto <D.20845>;
        <D.20844>:
        D.20846 = get_type_init_exception_for_vtable (vtable);
        mono_raise_exception (D.20846);
        <D.20845>:
        D.20799 = get_type_init_exception_for_vtable (vtable);
        return D.20799;
        <D.20836>:
        type_initialization_hash.8 = type_initialization_hash;
        lock = monoeg_g_hash_table_lookup (type_initialization_hash.8, vtable);
        if (lock == 0B) goto <D.20848>; else goto <D.20849>;
        <D.20848>:
        D.20850 = mono_domain_get ();
        if (D.20850 != domain) goto <D.20851>; else goto <D.20852>;
        <D.20851>:
        last_domain = mono_domain_get ();
        D.20853 = mono_domain_set (domain, 0);
        if (D.20853 == 0) goto <D.20854>; else goto <D.20855>;
        <D.20854>:
        vtable->initialized = 1;
        {
          int ret;

          ret = pthread_mutex_unlock (&type_initialization_section.mutex);
          if (ret != 0) goto <D.20856>; else goto <D.20857>;
          <D.20856>:
          monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
          <D.20857>:
          D.20858 = ret != 0;
          D.20859 = (long int) D.20858;
          D.20860 = __builtin_expect (D.20859, 0);
          if (D.20860 != 0) goto <D.20861>; else goto <D.20862>;
          <D.20861>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 330, "ret == 0");
          <D.20862>:
        }
        if (raise_exception != 0) goto <D.20863>; else goto <D.20864>;
        <D.20863>:
        D.20865 = mono_get_exception_appdomain_unloaded ();
        mono_raise_exception (D.20865);
        <D.20864>:
        D.20799 = mono_get_exception_appdomain_unloaded ();
        return D.20799;
        <D.20855>:
        <D.20852>:
        lock = monoeg_malloc (64);
        D.20866 = &lock->initialization_section;
        InitializeCriticalSection (D.20866);
        lock->initializing_tid = tid;
        lock->waiting_count = 1;
        lock->done = 0;
        {
          int ret;

          D.20867 = &lock->initialization_section.mutex;
          ret = pthread_mutex_lock (D.20867);
          if (ret != 0) goto <D.20868>; else goto <D.20869>;
          <D.20868>:
          monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
          <D.20869>:
          D.20870 = ret != 0;
          D.20871 = (long int) D.20870;
          D.20872 = __builtin_expect (D.20871, 0);
          if (D.20872 != 0) goto <D.20873>; else goto <D.20874>;
          <D.20873>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 342, "ret == 0");
          <D.20874>:
        }
        type_initialization_hash.8 = type_initialization_hash;
        monoeg_g_hash_table_insert_replace (type_initialization_hash.8, vtable, lock, 0);
        do_initialization = 1;
        goto <D.20875>;
        <D.20849>:
        {
          void * blocked;
          struct TypeInitializationLock * pending_lock;

          D.20878 = lock->initializing_tid;
          if (D.20878 == tid) goto <D.20876>; else goto <D.20879>;
          <D.20879>:
          D.20880 = lock->done;
          if (D.20880 != 0) goto <D.20876>; else goto <D.20877>;
          <D.20876>:
          {
            int ret;

            ret = pthread_mutex_unlock (&type_initialization_section.mutex);
            if (ret != 0) goto <D.20881>; else goto <D.20882>;
            <D.20881>:
            monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
            <D.20882>:
            D.20883 = ret != 0;
            D.20884 = (long int) D.20883;
            D.20885 = __builtin_expect (D.20884, 0);
            if (D.20885 != 0) goto <D.20886>; else goto <D.20887>;
            <D.20886>:
            monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 350, "ret == 0");
            <D.20887>:
          }
          D.20799 = 0B;
          return D.20799;
          <D.20877>:
          D.20878 = lock->initializing_tid;
          D.20888 = (long unsigned int) D.20878;
          blocked = (void *) D.20888;
          goto <D.19016>;
          <D.19015>:
          D.20889 = pending_lock->initializing_tid;
          if (D.20889 == tid) goto <D.20890>; else goto <D.20891>;
          <D.20890>:
          D.20892 = pending_lock->done;
          if (D.20892 == 0) goto <D.20893>; else goto <D.19014>;
          <D.20893>:
          {
            int ret;

            ret = pthread_mutex_unlock (&type_initialization_section.mutex);
            if (ret != 0) goto <D.20894>; else goto <D.20895>;
            <D.20894>:
            monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
            <D.20895>:
            D.20896 = ret != 0;
            D.20897 = (long int) D.20896;
            D.20898 = __builtin_expect (D.20897, 0);
            if (D.20898 != 0) goto <D.20899>; else goto <D.20900>;
            <D.20899>:
            monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 358, "ret == 0");
            <D.20900>:
          }
          D.20799 = 0B;
          return D.20799;
          <D.20891>:
          D.20889 = pending_lock->initializing_tid;
          D.20901 = (long unsigned int) D.20889;
          blocked = (void *) D.20901;
          <D.19016>:
          blocked_thread_hash.9 = blocked_thread_hash;
          pending_lock = monoeg_g_hash_table_lookup (blocked_thread_hash.9, blocked);
          if (pending_lock != 0B) goto <D.19015>; else goto <D.19014>;
          <D.19014>:
          D.20903 = lock->waiting_count;
          D.20904 = D.20903 + 1;
          lock->waiting_count = D.20904;
          D.20905 = (long unsigned int) tid;
          D.20906 = (void *) D.20905;
          blocked_thread_hash.9 = blocked_thread_hash;
          monoeg_g_hash_table_insert_replace (blocked_thread_hash.9, D.20906, lock, 0);
        }
        <D.20875>:
        {
          int ret;

          ret = pthread_mutex_unlock (&type_initialization_section.mutex);
          if (ret != 0) goto <D.20907>; else goto <D.20908>;
          <D.20907>:
          monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
          <D.20908>:
          D.20909 = ret != 0;
          D.20910 = (long int) D.20909;
          D.20911 = __builtin_expect (D.20910, 0);
          if (D.20911 != 0) goto <D.20912>; else goto <D.20913>;
          <D.20912>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 373, "ret == 0");
          <D.20913>:
        }
        if (do_initialization != 0) goto <D.20914>; else goto <D.20915>;
        <D.20914>:
        mono_runtime_invoke (method, 0B, 0B, &exc);
        exc.7 = exc;
        if (exc.7 != 0B) goto <D.20918>; else goto <D.20919>;
        <D.20918>:
        D.20800 = klass->image;
        D.20920 = mono_defaults.corlib;
        if (D.20800 != D.20920) goto <D.20916>; else goto <D.20921>;
        <D.20921>:
        {
          size_t __s1_len;
          size_t __s2_len;

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

            __s2 = klass->name_space;
            D.20925 = "System";
            D.20926 = MEM[(const unsigned char *)D.20925];
            D.20927 = (int) D.20926;
            D.20928 = *__s2;
            D.20929 = (int) D.20928;
            __result = D.20927 - D.20929;
            {
              D.20930 = __s2_len != 0;
              D.20931 = __result == 0;
              D.20932 = D.20930 & D.20931;
              if (D.20932 != 0) goto <D.20933>; else goto <D.20934>;
              <D.20933>:
              D.20935 = &MEM[(void *)"System" + 1B];
              D.20936 = *D.20935;
              D.20937 = (int) D.20936;
              D.20938 = __s2 + 1;
              D.20939 = *D.20938;
              D.20940 = (int) D.20939;
              __result = D.20937 - D.20940;
              D.20941 = __s2_len > 1;
              D.20931 = __result == 0;
              D.20942 = D.20941 & D.20931;
              if (D.20942 != 0) goto <D.20943>; else goto <D.20944>;
              <D.20943>:
              D.20945 = &MEM[(void *)"System" + 2B];
              D.20946 = *D.20945;
              D.20947 = (int) D.20946;
              D.20948 = __s2 + 2;
              D.20949 = *D.20948;
              D.20950 = (int) D.20949;
              __result = D.20947 - D.20950;
              D.20951 = __s2_len > 2;
              D.20931 = __result == 0;
              D.20952 = D.20951 & D.20931;
              if (D.20952 != 0) goto <D.20953>; else goto <D.20954>;
              <D.20953>:
              D.20955 = &MEM[(void *)"System" + 3B];
              D.20956 = *D.20955;
              D.20957 = (int) D.20956;
              D.20958 = __s2 + 3;
              D.20959 = *D.20958;
              D.20960 = (int) D.20959;
              __result = D.20957 - D.20960;
              <D.20954>:
              <D.20944>:
              <D.20934>:
            }
            D.19025 = __result;
          }
          iftmp.10 = -D.19025;
          goto <D.20961>;
          <D.20924>:
          D.20962 = klass->name_space;
          iftmp.10 = __builtin_strcmp (D.20962, "System");
          <D.20961>:
          D.19026 = iftmp.10;
        }
        if (D.19026 != 0) goto <D.20916>; else goto <D.20963>;
        <D.20963>:
        {
          size_t __s1_len;
          size_t __s2_len;

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

            __s2 = klass->name;
            D.20967 = "TypeInitializationException";
            D.20968 = MEM[(const unsigned char *)D.20967];
            D.20969 = (int) D.20968;
            D.20970 = *__s2;
            D.20971 = (int) D.20970;
            __result = D.20969 - D.20971;
            {
              D.20972 = __s2_len != 0;
              D.20973 = __result == 0;
              D.20974 = D.20972 & D.20973;
              if (D.20974 != 0) goto <D.20975>; else goto <D.20976>;
              <D.20975>:
              D.20977 = &MEM[(void *)"TypeInitializationException" + 1B];
              D.20978 = *D.20977;
              D.20979 = (int) D.20978;
              D.20980 = __s2 + 1;
              D.20981 = *D.20980;
              D.20982 = (int) D.20981;
              __result = D.20979 - D.20982;
              D.20983 = __s2_len > 1;
              D.20973 = __result == 0;
              D.20984 = D.20983 & D.20973;
              if (D.20984 != 0) goto <D.20985>; else goto <D.20986>;
              <D.20985>:
              D.20987 = &MEM[(void *)"TypeInitializationException" + 2B];
              D.20988 = *D.20987;
              D.20989 = (int) D.20988;
              D.20990 = __s2 + 2;
              D.20991 = *D.20990;
              D.20992 = (int) D.20991;
              __result = D.20989 - D.20992;
              D.20993 = __s2_len > 2;
              D.20973 = __result == 0;
              D.20994 = D.20993 & D.20973;
              if (D.20994 != 0) goto <D.20995>; else goto <D.20996>;
              <D.20995>:
              D.20997 = &MEM[(void *)"TypeInitializationException" + 3B];
              D.20998 = *D.20997;
              D.20999 = (int) D.20998;
              D.21000 = __s2 + 3;
              D.21001 = *D.21000;
              D.21002 = (int) D.21001;
              __result = D.20999 - D.21002;
              <D.20996>:
              <D.20986>:
              <D.20976>:
            }
            D.19034 = __result;
          }
          iftmp.11 = -D.19034;
          goto <D.21003>;
          <D.20966>:
          D.21004 = klass->name;
          iftmp.11 = __builtin_strcmp (D.21004, "TypeInitializationException");
          <D.21003>:
          D.19035 = iftmp.11;
        }
        if (D.19035 != 0) goto <D.20916>; else goto <D.20917>;
        <D.20916>:
        vtable->init_failed = 1;
        D.20962 = klass->name_space;
        if (D.20962 != 0B) goto <D.21007>; else goto <D.21005>;
        <D.21007>:
        D.20962 = klass->name_space;
        D.21008 = *D.20962;
        if (D.21008 != 0) goto <D.21009>; else goto <D.21005>;
        <D.21009>:
        D.21004 = klass->name;
        D.20962 = klass->name_space;
        full_name = monoeg_g_strdup_printf ("%s.%s", D.20962, D.21004);
        goto <D.21006>;
        <D.21005>:
        D.21004 = klass->name;
        full_name = monoeg_strdup (D.21004);
        <D.21006>:
        exc.7 = exc;
        exc_to_throw = mono_get_exception_type_initialization (full_name, exc.7);
        monoeg_g_free (full_name);
        {
          int ret;

          D.21010 = &domain->lock.mutex;
          ret = pthread_mutex_lock (D.21010);
          if (ret != 0) goto <D.21011>; else goto <D.21012>;
          <D.21011>:
          monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
          <D.21012>:
          D.21013 = ret != 0;
          D.21014 = (long int) D.21013;
          D.21015 = __builtin_expect (D.21014, 0);
          if (D.21015 != 0) goto <D.21016>; else goto <D.21017>;
          <D.21016>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 397, "ret == 0");
          <D.21017>:
        }
        D.21018 = domain->type_init_exception_hash;
        if (D.21018 == 0B) goto <D.21019>; else goto <D.21020>;
        <D.21019>:
        D.21021 = mono_g_hash_table_new_type (mono_aligned_addr_hash, 0B, 2);
        domain->type_init_exception_hash = D.21021;
        <D.21020>:
        D.21018 = domain->type_init_exception_hash;
        mono_g_hash_table_insert (D.21018, klass, exc_to_throw);
        {
          int ret;

          D.21010 = &domain->lock.mutex;
          ret = pthread_mutex_unlock (D.21010);
          if (ret != 0) goto <D.21022>; else goto <D.21023>;
          <D.21022>:
          monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
          <D.21023>:
          D.21024 = ret != 0;
          D.21025 = (long int) D.21024;
          D.21026 = __builtin_expect (D.21025, 0);
          if (D.21026 != 0) goto <D.21027>; else goto <D.21028>;
          <D.21027>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 401, "ret == 0");
          <D.21028>:
        }
        <D.20917>:
        <D.20919>:
        if (last_domain != 0B) goto <D.21029>; else goto <D.21030>;
        <D.21029>:
        mono_domain_set (last_domain, 1);
        <D.21030>:
        lock->done = 1;
        {
          int ret;

          D.20867 = &lock->initialization_section.mutex;
          ret = pthread_mutex_unlock (D.20867);
          if (ret != 0) goto <D.21031>; else goto <D.21032>;
          <D.21031>:
          monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
          <D.21032>:
          D.21033 = ret != 0;
          D.21034 = (long int) D.21033;
          D.21035 = __builtin_expect (D.21034, 0);
          if (D.21035 != 0) goto <D.21036>; else goto <D.21037>;
          <D.21036>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 407, "ret == 0");
          <D.21037>:
        }
        goto <D.21038>;
        <D.20915>:
        {
          int ret;

          D.20867 = &lock->initialization_section.mutex;
          ret = pthread_mutex_lock (D.20867);
          if (ret != 0) goto <D.21039>; else goto <D.21040>;
          <D.21039>:
          monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
          <D.21040>:
          D.21041 = ret != 0;
          D.21042 = (long int) D.21041;
          D.21043 = __builtin_expect (D.21042, 0);
          if (D.21043 != 0) goto <D.21044>; else goto <D.21045>;
          <D.21044>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 410, "ret == 0");
          <D.21045>:
        }
        {
          int ret;

          D.20867 = &lock->initialization_section.mutex;
          ret = pthread_mutex_unlock (D.20867);
          if (ret != 0) goto <D.21046>; else goto <D.21047>;
          <D.21046>:
          monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
          <D.21047>:
          D.21048 = ret != 0;
          D.21049 = (long int) D.21048;
          D.21050 = __builtin_expect (D.21049, 0);
          if (D.21050 != 0) goto <D.21051>; else goto <D.21052>;
          <D.21051>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 411, "ret == 0");
          <D.21052>:
        }
        <D.21038>:
        {
          int ret;

          ret = pthread_mutex_lock (&type_initialization_section.mutex);
          if (ret != 0) goto <D.21053>; else goto <D.21054>;
          <D.21053>:
          monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
          <D.21054>:
          D.21055 = ret != 0;
          D.21056 = (long int) D.21055;
          D.21057 = __builtin_expect (D.21056, 0);
          if (D.21057 != 0) goto <D.21058>; else goto <D.21059>;
          <D.21058>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 414, "ret == 0");
          <D.21059>:
        }
        D.20878 = lock->initializing_tid;
        if (D.20878 != tid) goto <D.21060>; else goto <D.21061>;
        <D.21060>:
        D.20905 = (long unsigned int) tid;
        D.21062 = (const void *) D.20905;
        blocked_thread_hash.9 = blocked_thread_hash;
        monoeg_g_hash_table_remove (blocked_thread_hash.9, D.21062);
        <D.21061>:
        D.20903 = lock->waiting_count;
        D.21063 = D.20903 + 4294967295;
        lock->waiting_count = D.21063;
        D.20903 = lock->waiting_count;
        if (D.20903 == 0) goto <D.21064>; else goto <D.21065>;
        <D.21064>:
        D.20866 = &lock->initialization_section;
        DeleteCriticalSection (D.20866);
        type_initialization_hash.8 = type_initialization_hash;
        monoeg_g_hash_table_remove (type_initialization_hash.8, vtable);
        monoeg_g_free (lock);
        <D.21065>:
        mono_memory_barrier ();
        D.20795 = BIT_FIELD_REF <*vtable, 8, 344>;
        D.20834 = D.20795 & 4;
        if (D.20834 == 0) goto <D.21066>; else goto <D.21067>;
        <D.21066>:
        vtable->initialized = 1;
        <D.21067>:
        {
          int ret;

          ret = pthread_mutex_unlock (&type_initialization_section.mutex);
          if (ret != 0) goto <D.21068>; else goto <D.21069>;
          <D.21068>:
          monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
          <D.21069>:
          D.21070 = ret != 0;
          D.21071 = (long int) D.21070;
          D.21072 = __builtin_expect (D.21071, 0);
          if (D.21072 != 0) goto <D.21073>; else goto <D.21074>;
          <D.21073>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 426, "ret == 0");
          <D.21074>:
        }
        D.20795 = BIT_FIELD_REF <*vtable, 8, 344>;
        D.20834 = D.20795 & 4;
        if (D.20834 != 0) goto <D.21075>; else goto <D.21076>;
        <D.21075>:
        if (raise_exception != 0) goto <D.21077>; else goto <D.21078>;
        <D.21077>:
        D.21079 = get_type_init_exception_for_vtable (vtable);
        mono_raise_exception (D.21079);
        <D.21078>:
        D.20799 = get_type_init_exception_for_vtable (vtable);
        return D.20799;
        <D.21076>:
      }
      goto <D.21080>;
      <D.20816>:
      vtable->initialized = 1;
      D.20799 = 0B;
      return D.20799;
      <D.21080>:
      D.20799 = 0B;
      return D.20799;
    }
  finally
    {
      exc = {CLOBBER};
    }
}


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)
{
  unsigned char D.21087;
  unsigned char 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, 8, 344>;
  D.21088 = D.21087 & 4;
  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.18983>:
  goto <D.18983>;
  <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.21118 = klass->name;
  D.21114 = klass->name_space;
  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;
}


mono_release_type_locks (struct MonoInternalThread * thread)
{
  _Bool D.21123;
  long int D.21124;
  long int D.21125;
  long unsigned int D.21128;
  void * D.21129;
  struct GHashTable * type_initialization_hash.12;
  _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>:
  }
  D.21128 = thread->tid;
  D.21129 = (void *) D.21128;
  type_initialization_hash.12 = type_initialization_hash;
  monoeg_g_hash_table_foreach_remove (type_initialization_hash.12, release_type_locks, D.21129);
  {
    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.13;
  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.13 = (long int) user;
  D.21140 = (unsigned int) user.13;
  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;
}


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


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


mono_get_runtime_callbacks ()
{
  struct MonoRuntimeCallbacks * D.21164;

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


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

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


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

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


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

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


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


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

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


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

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


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

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


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


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


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


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

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


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

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


mono_runtime_create_delegate_trampoline (struct MonoClass * klass)
{
  void * D.21198;
  void * (*<T1df0>) (struct MonoDomain *, struct MonoClass *) arch_create_delegate_trampoline.20;
  struct MonoDomain * D.21200;

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


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


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

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


mono_class_compute_bitmap (struct MonoClass * class, gsize * bitmap, int size, int offset, int * max_set, gboolean static_fields)
{
  gsize * D.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;
  int D.19144;
  int iftmp.22;
  int D.19140;
  const char[10] * D.21236;
  unsigned char D.21237;
  int D.21238;
  unsigned char D.21239;
  int D.21240;
  _Bool D.21241;
  _Bool D.21242;
  _Bool D.21243;
  const unsigned char * D.21246;
  unsigned char D.21247;
  int D.21248;
  const unsigned char * D.21249;
  unsigned char D.21250;
  int D.21251;
  _Bool D.21252;
  _Bool D.21253;
  const unsigned char * D.21256;
  unsigned char D.21257;
  int D.21258;
  const unsigned char * D.21259;
  unsigned char D.21260;
  int D.21261;
  _Bool D.21262;
  _Bool D.21263;
  const unsigned char * D.21266;
  unsigned char D.21267;
  int D.21268;
  const unsigned char * D.21269;
  unsigned char D.21270;
  int D.21271;
  const char * D.21273;
  int D.21276;
  long unsigned int D.21277;
  gsize * D.21278;
  struct MonoType * D.21281;
  short unsigned int D.21282;
  int D.21283;
  int D.21284;
  int D.21287;
  unsigned char D.21293;
  unsigned char D.21294;
  int D.21298;
  long unsigned int D.21301;
  long unsigned int D.21302;
  unsigned int offset.23;
  unsigned char D.21304;
  int D.21305;
  long unsigned int D.21306;
  _Bool D.21307;
  long int D.21308;
  long int D.21309;
  unsigned int size.24;
  _Bool D.21313;
  unsigned int max_size.25;
  _Bool D.21315;
  _Bool D.21316;
  int D.21317;
  _Bool D.21318;
  long int D.21319;
  long int D.21320;
  unsigned int D.21323;
  long unsigned int D.21324;
  long unsigned int D.21325;
  gsize * D.21326;
  long unsigned int D.21327;
  int pos.26;
  int D.21329;
  long unsigned int D.21330;
  long unsigned int D.21331;
  int D.21332;
  unsigned int D.21333;
  unsigned int D.21334;
  int D.21335;
  int D.21336;
  unsigned int D.21341;
  long unsigned int D.21342;
  long unsigned int D.21343;
  gsize * D.21344;
  long unsigned int D.21345;
  long unsigned int D.21346;
  unsigned char D.21347;
  unsigned char D.21348;
  unsigned int D.21351;
  int D.21352;
  const char * D.21353;
  struct MonoClass * D.21354;
  char * D.21355;
  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>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = class->name;
      D.21236 = "Ephemeron";
      D.21237 = MEM[(const unsigned char *)D.21236];
      D.21238 = (int) D.21237;
      D.21239 = *__s2;
      D.21240 = (int) D.21239;
      __result = D.21238 - D.21240;
      {
        D.21241 = __s1_len != 0;
        D.21242 = __result == 0;
        D.21243 = D.21241 & D.21242;
        if (D.21243 != 0) goto <D.21244>; else goto <D.21245>;
        <D.21244>:
        D.21246 = &MEM[(void *)"Ephemeron" + 1B];
        D.21247 = *D.21246;
        D.21248 = (int) D.21247;
        D.21249 = __s2 + 1;
        D.21250 = *D.21249;
        D.21251 = (int) D.21250;
        __result = D.21248 - D.21251;
        D.21252 = __s1_len > 1;
        D.21242 = __result == 0;
        D.21253 = D.21252 & D.21242;
        if (D.21253 != 0) goto <D.21254>; else goto <D.21255>;
        <D.21254>:
        D.21256 = &MEM[(void *)"Ephemeron" + 2B];
        D.21257 = *D.21256;
        D.21258 = (int) D.21257;
        D.21259 = __s2 + 2;
        D.21260 = *D.21259;
        D.21261 = (int) D.21260;
        __result = D.21258 - D.21261;
        D.21262 = __s1_len > 2;
        D.21242 = __result == 0;
        D.21263 = D.21262 & D.21242;
        if (D.21263 != 0) goto <D.21264>; else goto <D.21265>;
        <D.21264>:
        D.21266 = &MEM[(void *)"Ephemeron" + 3B];
        D.21267 = *D.21266;
        D.21268 = (int) D.21267;
        D.21269 = __s2 + 3;
        D.21270 = *D.21269;
        D.21271 = (int) D.21270;
        __result = D.21268 - D.21271;
        <D.21265>:
        <D.21255>:
        <D.21245>:
      }
      D.19140 = __result;
    }
    iftmp.22 = D.19140;
    goto <D.21272>;
    <D.21235>:
    D.21273 = class->name;
    iftmp.22 = __builtin_strcmp ("Ephemeron", D.21273);
    <D.21272>:
    D.19144 = iftmp.22;
  }
  if (D.19144 == 0) goto <D.21274>; else goto <D.21275>;
  <D.21274>:
  *max_set = 0;
  D.21276 = size / 8;
  D.21277 = (long unsigned int) D.21276;
  memset (bitmap, 0, D.21277);
  D.21278 = bitmap;
  return D.21278;
  <D.21275>:
  <D.21232>:
  <D.21228>:
  p = class;
  goto <D.19179>;
  <D.19178>:
  {
    void * iter;

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

          if (static_fields != 0) goto <D.21279>; else goto <D.21280>;
          <D.21279>:
          D.21281 = field->type;
          D.21282 = D.21281->attrs;
          D.21283 = (int) D.21282;
          D.21284 = D.21283 & 272;
          if (D.21284 == 0) goto <D.21285>; else goto <D.21286>;
          <D.21285>:
          // predicted unlikely by continue predictor.
          goto <D.19147>;
          <D.21286>:
          D.21281 = field->type;
          D.21282 = D.21281->attrs;
          D.21283 = (int) D.21282;
          D.21287 = D.21283 & 64;
          if (D.21287 != 0) goto <D.21288>; else goto <D.21289>;
          <D.21288>:
          // predicted unlikely by continue predictor.
          goto <D.19147>;
          <D.21289>:
          goto <D.21290>;
          <D.21280>:
          D.21281 = field->type;
          D.21282 = D.21281->attrs;
          D.21283 = (int) D.21282;
          D.21284 = D.21283 & 272;
          if (D.21284 != 0) goto <D.21291>; else goto <D.21292>;
          <D.21291>:
          // predicted unlikely by continue predictor.
          goto <D.19147>;
          <D.21292>:
          <D.21290>:
          D.21281 = field->type;
          D.21293 = BIT_FIELD_REF <*D.21281, 8, 88>;
          D.21294 = D.21293 & 64;
          if (D.21294 != 0) goto <D.19148>; else goto <D.21295>;
          <D.21295>:
          if (static_fields != 0) goto <D.21296>; else goto <D.21297>;
          <D.21296>:
          D.21298 = field->offset;
          if (D.21298 == -1) goto <D.21299>; else goto <D.21300>;
          <D.21299>:
          // predicted unlikely by continue predictor.
          goto <D.19147>;
          <D.21300>:
          <D.21297>:
          D.21298 = field->offset;
          D.21301 = (long unsigned int) D.21298;
          D.21302 = D.21301 / 8;
          pos = (guint32) D.21302;
          offset.23 = (unsigned int) offset;
          pos = pos + offset.23;
          D.21281 = field->type;
          type = mono_type_get_underlying_type (D.21281);
          D.21304 = type->type;
          D.21305 = (int) D.21304;
          switch (D.21305) <default: <D.19174>, case 2: <D.19172>, case 3: <D.19173>, case 4: <D.19162>, case 5: <D.19163>, case 6: <D.19164>, case 7: <D.19165>, case 8: <D.19166>, case 9: <D.19167>, case 10: <D.19168>, case 11: <D.19169>, case 12: <D.19170>, case 13: <D.19171>, case 14: <D.19154>, case 15: <D.19150>, case 17: <D.19160>, case 18: <D.19156>, case 20: <D.19158>, case 21: <D.19159>, case 24: <D.19149>, case 25: <D.19153>, case 27: <D.19151>, case 28: <D.19157>, case 29: <D.19155>>
          <D.19149>:
          <D.19150>:
          <D.19151>:
          goto <D.19152>;
          <D.19153>:
          goto <D.19152>;
          <D.19154>:
          <D.19155>:
          <D.19156>:
          <D.19157>:
          <D.19158>:
          D.21298 = field->offset;
          D.21301 = (long unsigned int) D.21298;
          D.21306 = D.21301 & 7;
          D.21307 = D.21306 != 0;
          D.21308 = (long int) D.21307;
          D.21309 = __builtin_expect (D.21308, 0);
          if (D.21309 != 0) goto <D.21310>; else goto <D.21311>;
          <D.21310>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 722, "(field->offset % sizeof(gpointer)) == 0");
          <D.21311>:
          size.24 = (unsigned int) size;
          D.21313 = size.24 <= pos;
          max_size.25 = (unsigned int) max_size;
          D.21315 = max_size.25 < pos;
          D.21316 = D.21313 & D.21315;
          D.21317 = (int) D.21316;
          D.21318 = D.21317 != 0;
          D.21319 = (long int) D.21318;
          D.21320 = __builtin_expect (D.21319, 0);
          if (D.21320 != 0) goto <D.21321>; else goto <D.21322>;
          <D.21321>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 724, "pos < size || pos <= max_size");
          <D.21322>:
          D.21323 = pos / 64;
          D.21324 = (long unsigned int) D.21323;
          D.21325 = D.21324 * 8;
          D.21326 = bitmap + D.21325;
          D.21324 = (long unsigned int) D.21323;
          D.21325 = D.21324 * 8;
          D.21326 = bitmap + D.21325;
          D.21327 = *D.21326;
          pos.26 = (int) pos;
          D.21329 = pos.26 & 63;
          D.21330 = 1 << D.21329;
          D.21331 = D.21327 | D.21330;
          *D.21326 = D.21331;
          D.21332 = *max_set;
          D.21333 = (unsigned int) D.21332;
          D.21334 = MAX_EXPR <D.21333, pos>;
          D.21335 = (int) D.21334;
          *max_set = D.21335;
          goto <D.19152>;
          <D.19159>:
          D.21336 = mono_type_generic_inst_is_valuetype (type);
          if (D.21336 == 0) goto <D.21337>; else goto <D.21338>;
          <D.21337>:
          D.21298 = field->offset;
          D.21301 = (long unsigned int) D.21298;
          D.21306 = D.21301 & 7;
          D.21307 = D.21306 != 0;
          D.21308 = (long int) D.21307;
          D.21309 = __builtin_expect (D.21308, 0);
          if (D.21309 != 0) goto <D.21339>; else goto <D.21340>;
          <D.21339>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 730, "(field->offset % sizeof(gpointer)) == 0");
          <D.21340>:
          D.21341 = pos / 64;
          D.21342 = (long unsigned int) D.21341;
          D.21343 = D.21342 * 8;
          D.21344 = bitmap + D.21343;
          D.21342 = (long unsigned int) D.21341;
          D.21343 = D.21342 * 8;
          D.21344 = bitmap + D.21343;
          D.21345 = *D.21344;
          pos.26 = (int) pos;
          D.21329 = pos.26 & 63;
          D.21330 = 1 << D.21329;
          D.21346 = D.21345 | D.21330;
          *D.21344 = D.21346;
          D.21332 = *max_set;
          D.21333 = (unsigned int) D.21332;
          D.21334 = MAX_EXPR <D.21333, pos>;
          D.21335 = (int) D.21334;
          *max_set = D.21335;
          goto <D.19152>;
          <D.21338>:
          <D.19160>:
          {
            struct MonoClass * fclass;

            D.21281 = field->type;
            fclass = mono_class_from_mono_type (D.21281);
            D.21347 = BIT_FIELD_REF <*fclass, 8, 280>;
            D.21348 = D.21347 & 8;
            if (D.21348 != 0) goto <D.21349>; else goto <D.21350>;
            <D.21349>:
            D.21351 = pos + 4294967294;
            D.21352 = (int) D.21351;
            compute_class_bitmap (fclass, bitmap, size, D.21352, max_set, 0);
            <D.21350>:
            goto <D.19152>;
          }
          <D.19162>:
          <D.19163>:
          <D.19164>:
          <D.19165>:
          <D.19166>:
          <D.19167>:
          <D.19168>:
          <D.19169>:
          <D.19170>:
          <D.19171>:
          <D.19172>:
          <D.19173>:
          goto <D.19152>;
          <D.19174>:
          D.21353 = field->name;
          D.21354 = field->parent;
          D.21355 = mono_type_get_full_name (D.21354);
          D.21304 = type->type;
          D.21305 = (int) D.21304;
          monoeg_g_log (0B, 4, "compute_class_bitmap: Invalid type %x for field %s:%s\n", D.21305, D.21355, D.21353);
          <D.19175>:
          goto <D.19175>;
          <D.19152>:
        }
        <D.19147>:
        field = mono_class_get_fields (p, &iter);
        if (field != 0B) goto <D.19176>; else goto <D.19148>;
        <D.19148>:
        if (static_fields != 0) goto <D.19177>; else goto <D.21356>;
        <D.21356>:
      }
    finally
      {
        iter = {CLOBBER};
      }
  }
  p = p->parent;
  <D.19179>:
  if (p != 0B) goto <D.19178>; else goto <D.19177>;
  <D.19177>:
  D.21278 = bitmap;
  return D.21278;
}


memset (void * __dest, int __ch, size_t __len)
{
  int D.21363;
  int D.21368;
  void * D.21370;
  long unsigned int D.21371;

  D.21363 = __builtin_constant_p (__len);
  if (D.21363 != 0) goto <D.21364>; else goto <D.21365>;
  <D.21364>:
  if (__len == 0) goto <D.21366>; else goto <D.21367>;
  <D.21366>:
  D.21368 = __builtin_constant_p (__ch);
  if (D.21368 == 0) goto <D.21361>; else goto <D.21369>;
  <D.21369>:
  if (__ch != 0) goto <D.21361>; else goto <D.21362>;
  <D.21361>:
  __warn_memset_zero_len ();
  D.21370 = __dest;
  return D.21370;
  <D.21362>:
  <D.21367>:
  <D.21365>:
  D.21371 = __builtin_object_size (__dest, 0);
  D.21370 = __builtin___memset_chk (__dest, __ch, __len, D.21371);
  return D.21370;
}


mono_string_alloc (int length)
{
  struct MonoString * D.21373;
  struct MonoDomain * D.21374;

  D.21374 = mono_domain_get ();
  D.21373 = mono_string_new_size (D.21374, length);
  return D.21373;
}


mono_class_compute_gc_descriptor (struct MonoClass * class)
{
  int gcj_inited.27;
  struct MonoMethodSignature * D.21379;
  struct MonoMethodSignature * D.21380;
  struct MonoMethodSignature * D.21381;
  struct MonoMethodSignature * D.21382;
  unsigned char D.21383;
  unsigned char D.21384;
  unsigned char D.21387;
  unsigned char D.21388;
  struct MonoClass * D.21391;
  void * D.21394;
  unsigned char D.21396;
  struct MonoClass * D.21399;
  unsigned char D.21400;
  unsigned char D.21401;
  unsigned char D.21404;
  _Bool D.21405;
  int D.21406;
  void * D.21407;
  int D.21409;
  long unsigned int D.21410;
  int D.21411;
  long unsigned int D.21412;
  long unsigned int D.21413;
  int D.21414;
  void * D.21415;
  int D.21419;
  long unsigned int D.21420;
  int max_set.28;
  int D.21422;
  void * D.21423;
  int max_set;
  gsize * bitmap;
  gsize default_bitmap[4];
  static gboolean gcj_inited = 0;

  try
    {
      max_set = 0;
      default_bitmap = {};
      gcj_inited.27 = gcj_inited;
      if (gcj_inited.27 == 0) goto <D.21377>; else goto <D.21378>;
      <D.21377>:
      mono_loader_lock ();
      D.21379 = mono_create_icall_signature ("object ptr");
      mono_register_jit_icall (mono_object_new_ptrfree, "mono_object_new_ptrfree", D.21379, 0);
      D.21380 = mono_create_icall_signature ("object ptr");
      mono_register_jit_icall (mono_object_new_ptrfree_box, "mono_object_new_ptrfree_box", D.21380, 0);
      D.21381 = mono_create_icall_signature ("object ptr");
      mono_register_jit_icall (mono_object_new_fast, "mono_object_new_fast", D.21381, 0);
      D.21382 = mono_create_icall_signature ("object int");
      mono_register_jit_icall (mono_string_alloc, "mono_string_alloc", D.21382, 0);
      gcj_inited = 1;
      mono_loader_unlock ();
      <D.21378>:
      D.21383 = BIT_FIELD_REF <*class, 8, 256>;
      D.21384 = D.21383 & 1;
      if (D.21384 == 0) goto <D.21385>; else goto <D.21386>;
      <D.21385>:
      mono_class_init (class);
      <D.21386>:
      D.21387 = BIT_FIELD_REF <*class, 8, 280>;
      D.21388 = D.21387 & 2;
      if (D.21388 != 0) goto <D.21389>; else goto <D.21390>;
      <D.21389>:
      return;
      <D.21390>:
      class->gc_descr_inited = 1;
      class->gc_descr = 0B;
      bitmap = &default_bitmap;
      D.21391 = mono_defaults.string_class;
      if (D.21391 == class) goto <D.21392>; else goto <D.21393>;
      <D.21392>:
      D.21394 = mono_gc_make_descr_for_string (bitmap, 2);
      class->gc_descr = D.21394;
      goto <D.21395>;
      <D.21393>:
      D.21396 = class->rank;
      if (D.21396 != 0) goto <D.21397>; else goto <D.21398>;
      <D.21397>:
      D.21399 = class->element_class;
      mono_class_compute_gc_descriptor (D.21399);
      D.21399 = class->element_class;
      D.21400 = BIT_FIELD_REF <*D.21399, 8, 256>;
      D.21401 = D.21400 & 8;
      if (D.21401 == 0) goto <D.21402>; else goto <D.21403>;
      <D.21402>:
      {
        gsize abm;

        try
          {
            abm = 1;
            D.21404 = class->byval_arg.type;
            D.21405 = D.21404 == 29;
            D.21406 = (int) D.21405;
            D.21407 = mono_gc_make_descr_for_array (D.21406, &abm, 1, 8);
            class->gc_descr = D.21407;
          }
        finally
          {
            abm = {CLOBBER};
          }
      }
      goto <D.21408>;
      <D.21403>:
      D.21399 = class->element_class;
      bitmap = compute_class_bitmap (D.21399, &default_bitmap, 256, -2, &max_set, 0);
      D.21409 = mono_array_element_size (class);
      D.21410 = (long unsigned int) D.21409;
      D.21411 = mono_array_element_size (class);
      D.21412 = (long unsigned int) D.21411;
      D.21413 = D.21412 / 8;
      D.21414 = (int) D.21413;
      D.21404 = class->byval_arg.type;
      D.21405 = D.21404 == 29;
      D.21406 = (int) D.21405;
      D.21415 = mono_gc_make_descr_for_array (D.21406, bitmap, D.21414, D.21410);
      class->gc_descr = D.21415;
      if (&default_bitmap != bitmap) goto <D.21416>; else goto <D.21417>;
      <D.21416>:
      monoeg_g_free (bitmap);
      <D.21417>:
      <D.21408>:
      goto <D.21418>;
      <D.21398>:
      bitmap = compute_class_bitmap (class, &default_bitmap, 256, 0, &max_set, 0);
      D.21419 = class->instance_size;
      D.21420 = (long unsigned int) D.21419;
      max_set.28 = max_set;
      D.21422 = max_set.28 + 1;
      D.21423 = mono_gc_make_descr_for_object (bitmap, D.21422, D.21420);
      class->gc_descr = D.21423;
      if (&default_bitmap != bitmap) goto <D.21424>; else goto <D.21425>;
      <D.21424>:
      monoeg_g_free (bitmap);
      <D.21425>:
      <D.21418>:
      <D.21395>:
    }
  finally
    {
      max_set = {CLOBBER};
      default_bitmap = {CLOBBER};
    }
}


mono_object_new_ptrfree_box (struct MonoVTable * vtable)
{
  struct MonoClass * D.21429;
  int D.21430;
  long unsigned int D.21431;
  struct MonoObject * D.21432;
  struct MonoObject * obj;

  D.21429 = vtable->klass;
  D.21430 = D.21429->instance_size;
  D.21431 = (long unsigned int) D.21430;
  obj = mono_gc_alloc_obj (vtable, D.21431);
  D.21432 = obj;
  return D.21432;
}


mono_object_new_ptrfree (struct MonoVTable * vtable)
{
  struct MonoClass * D.21434;
  int D.21435;
  long unsigned int D.21436;
  struct MonoObject * D.21437;
  struct MonoObject * obj;

  D.21434 = vtable->klass;
  D.21435 = D.21434->instance_size;
  D.21436 = (long unsigned int) D.21435;
  obj = mono_gc_alloc_obj (vtable, D.21436);
  D.21437 = obj;
  return D.21437;
}


mono_method_get_imt_slot (struct MonoMethod * method)
{
  unsigned char D.21439;
  unsigned char D.21440;
  short unsigned int D.21443;
  int D.21444;
  long unsigned int D.21445;
  long unsigned int D.21446;
  struct MonoClass * D.21447;
  unsigned int D.21448;
  unsigned int D.21449;
  unsigned char D.21452;
  const char * D.21457;
  const char * D.21458;
  const char * D.21459;
  unsigned int D.21460;
  guint32 * D.21461;
  unsigned int D.21462;
  guint32 * D.21463;
  unsigned int D.21464;
  guint32 * D.21465;
  struct MonoType * D.21466;
  unsigned int D.21467;
  int D.21468;
  long unsigned int D.21469;
  long unsigned int D.21470;
  guint32 * D.21471;
  struct MonoType * D.21472;
  unsigned int D.21473;
  unsigned int hashes_count.29;
  unsigned int D.21475;
  unsigned int D.21476;
  unsigned int D.21477;
  unsigned int D.21478;
  unsigned int D.21479;
  unsigned int D.21480;
  unsigned int D.21481;
  unsigned int D.21482;
  unsigned int D.21483;
  unsigned int D.21484;
  unsigned int D.21485;
  unsigned int D.21486;
  unsigned int D.21487;
  unsigned int D.21488;
  unsigned int D.21489;
  unsigned int D.21490;
  guint32 D.21492;
  struct MonoMethodSignature * sig;
  int hashes_count;
  guint32 * hashes_start;
  guint32 * hashes;
  guint32 a;
  guint32 b;
  guint32 c;
  int i;

  D.21439 = BIT_FIELD_REF <*method, 8, 264>;
  D.21440 = D.21439 & 16;
  if (D.21440 != 0) goto <D.21441>; else goto <D.21442>;
  <D.21441>:
  method = MEM[(struct MonoMethodInflated *)method].declaring;
  <D.21442>:
  sig = mono_method_signature (method);
  D.21443 = sig->param_count;
  D.21444 = (int) D.21443;
  hashes_count = D.21444 + 4;
  D.21445 = (long unsigned int) hashes_count;
  D.21446 = D.21445 * 4;
  hashes_start = malloc (D.21446);
  hashes = hashes_start;
  D.21447 = method->klass;
  D.21448 = D.21447->flags;
  D.21449 = D.21448 & 32;
  if (D.21449 == 0) goto <D.21450>; else goto <D.21451>;
  <D.21450>:
  D.21447 = method->klass;
  D.21452 = D.21447->byval_arg.type;
  if (D.21452 != 19) goto <D.21453>; else goto <D.21454>;
  <D.21453>:
  D.21447 = method->klass;
  D.21452 = D.21447->byval_arg.type;
  if (D.21452 != 30) goto <D.21455>; else goto <D.21456>;
  <D.21455>:
  D.21457 = method->name;
  D.21447 = method->klass;
  D.21458 = D.21447->name;
  D.21447 = method->klass;
  D.21459 = D.21447->name_space;
  monoeg_g_log (0B, 4, "mono_method_get_imt_slot: %s.%s.%s is not an interface MonoMethod", D.21459, D.21458, D.21457);
  <D.19238>:
  goto <D.19238>;
  <D.21456>:
  <D.21454>:
  <D.21451>:
  D.21447 = method->klass;
  D.21458 = D.21447->name;
  D.21460 = mono_metadata_str_hash (D.21458);
  *hashes = D.21460;
  D.21461 = hashes + 4;
  D.21447 = method->klass;
  D.21459 = D.21447->name_space;
  D.21462 = mono_metadata_str_hash (D.21459);
  *D.21461 = D.21462;
  D.21463 = hashes + 8;
  D.21457 = method->name;
  D.21464 = mono_metadata_str_hash (D.21457);
  *D.21463 = D.21464;
  D.21465 = hashes + 12;
  D.21466 = sig->ret;
  D.21467 = mono_metadata_type_hash (D.21466);
  *D.21465 = D.21467;
  i = 0;
  goto <D.19240>;
  <D.19239>:
  D.21468 = i + 4;
  D.21469 = (long unsigned int) D.21468;
  D.21470 = D.21469 * 4;
  D.21471 = hashes + D.21470;
  D.21472 = sig->params[i];
  D.21473 = mono_metadata_type_hash (D.21472);
  *D.21471 = D.21473;
  i = i + 1;
  <D.19240>:
  D.21443 = sig->param_count;
  D.21444 = (int) D.21443;
  if (D.21444 > i) goto <D.19239>; else goto <D.19241>;
  <D.19241>:
  hashes_count.29 = (unsigned int) hashes_count;
  D.21475 = hashes_count.29 << 2;
  c = D.21475 + 3735928559;
  b = c;
  a = b;
  goto <D.19243>;
  <D.19242>:
  D.21476 = *hashes;
  a = D.21476 + a;
  D.21461 = hashes + 4;
  D.21477 = *D.21461;
  b = D.21477 + b;
  D.21463 = hashes + 8;
  D.21478 = *D.21463;
  c = D.21478 + c;
  a = a - c;
  D.21479 = c r>> 28;
  a = D.21479 ^ a;
  c = c + b;
  b = b - a;
  D.21480 = a r>> 26;
  b = D.21480 ^ b;
  a = a + c;
  c = c - b;
  D.21481 = b r>> 24;
  c = D.21481 ^ c;
  b = b + a;
  a = a - c;
  D.21482 = c r>> 16;
  a = D.21482 ^ a;
  c = c + b;
  b = b - a;
  D.21483 = a r>> 13;
  b = D.21483 ^ b;
  a = a + c;
  c = c - b;
  D.21484 = b r>> 28;
  c = D.21484 ^ c;
  b = b + a;
  hashes_count = hashes_count + -3;
  hashes = hashes + 12;
  <D.19243>:
  if (hashes_count > 3) goto <D.19242>; else goto <D.19244>;
  <D.19244>:
  switch (hashes_count) <default: <D.21491>, case 0: <D.19248>, case 1: <D.19247>, case 2: <D.19246>, case 3: <D.19245>>
  <D.19245>:
  D.21463 = hashes + 8;
  D.21478 = *D.21463;
  c = D.21478 + c;
  <D.19246>:
  D.21461 = hashes + 4;
  D.21477 = *D.21461;
  b = D.21477 + b;
  <D.19247>:
  D.21476 = *hashes;
  a = D.21476 + a;
  c = c ^ b;
  D.21485 = b r>> 18;
  c = c - D.21485;
  a = a ^ c;
  D.21486 = c r>> 21;
  a = a - D.21486;
  b = b ^ a;
  D.21487 = a r>> 7;
  b = b - D.21487;
  c = c ^ b;
  D.21488 = b r>> 16;
  c = c - D.21488;
  a = a ^ c;
  D.21479 = c r>> 28;
  a = a - D.21479;
  b = b ^ a;
  D.21489 = a r>> 18;
  b = b - D.21489;
  c = c ^ b;
  D.21490 = b r>> 8;
  c = c - D.21490;
  <D.19248>:
  goto <D.19249>;
  <D.21491>:
  <D.19249>:
  free (hashes_start);
  D.21492 = c % 19;
  return D.21492;
}


mono_vtable_build_imt_slot (struct MonoVTable * vtable, int imt_slot)
{
  unsigned int imt_slot.30;
  _Bool D.21495;
  long int D.21496;
  long int D.21497;
  struct MonoDomain * D.21500;
  union mono_mutex_t * D.21501;
  _Bool D.21504;
  long int D.21505;
  long int D.21506;
  long unsigned int D.21509;
  long unsigned int D.21510;
  void * * D.21511;
  void * D.21512;
  void * (*<T2550>) (int) D.21513;
  void * D.21514;
  struct MonoClass * D.21517;
  _Bool D.21520;
  long int D.21521;
  long int D.21522;
  void * * imt;

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

    D.21500 = vtable->domain;
    D.21501 = &D.21500->lock.mutex;
    ret = pthread_mutex_lock (D.21501);
    if (ret != 0) goto <D.21502>; else goto <D.21503>;
    <D.21502>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
    <D.21503>:
    D.21504 = ret != 0;
    D.21505 = (long int) D.21504;
    D.21506 = __builtin_expect (D.21505, 0);
    if (D.21506 != 0) goto <D.21507>; else goto <D.21508>;
    <D.21507>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 1460, "ret == 0");
    <D.21508>:
  }
  D.21509 = (long unsigned int) imt_slot;
  D.21510 = D.21509 * 8;
  D.21511 = imt + D.21510;
  D.21512 = *D.21511;
  D.21513 = callbacks.get_imt_trampoline;
  D.21514 = D.21513 (imt_slot);
  if (D.21512 == D.21514) goto <D.21515>; else goto <D.21516>;
  <D.21515>:
  D.21500 = vtable->domain;
  D.21517 = vtable->klass;
  build_imt_slots (D.21517, vtable, D.21500, imt, 0B, imt_slot);
  <D.21516>:
  {
    int ret;

    D.21500 = vtable->domain;
    D.21501 = &D.21500->lock.mutex;
    ret = pthread_mutex_unlock (D.21501);
    if (ret != 0) goto <D.21518>; else goto <D.21519>;
    <D.21518>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.21519>:
    D.21520 = ret != 0;
    D.21521 = (long int) D.21520;
    D.21522 = __builtin_expect (D.21521, 0);
    if (D.21522 != 0) goto <D.21523>; else goto <D.21524>;
    <D.21523>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 1464, "ret == 0");
    <D.21524>:
  }
  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.21525;
  long unsigned int D.21526;
  long unsigned int D.21527;
  struct MonoClass * * D.21528;
  guint16 * D.21529;
  long unsigned int D.21530;
  guint16 * D.21531;
  short unsigned int D.21532;
  int D.21533;
  unsigned char D.21538;
  unsigned char D.21539;
  struct MonoGenericClass * D.21542;
  struct MonoClass * D.21543;
  unsigned int D.21544;
  unsigned int slot_num.31;
  unsigned char D.21548;
  unsigned char D.21549;
  short unsigned int D.21552;
  int D.21553;
  int D.21554;
  unsigned int method_slot_in_interface.32;
  unsigned int D.21558;
  short unsigned int D.21559;
  int D.21560;
  int D.21563;
  unsigned int method_slot_in_interface.33;
  unsigned int D.21565;
  unsigned int interface_offset.34;
  unsigned int D.21567;
  _Bool D.21568;
  _Bool D.21569;
  _Bool D.21570;
  void * * D.21573;
  struct MonoImtBuilderEntry * * D.21576;
  struct MonoImtBuilderEntry * D.21577;
  struct _MonoImtBuilderEntry * D.21580;
  int D.21581;
  int D.21582;
  int D.21583;
  int D.21584;
  int D.21585;
  int D.21588;
  unsigned int D.21589;
  unsigned int imt_collisions_bitmap.35;
  unsigned int imt_collisions_bitmap.36;
  void * iftmp.37;
  void * (*<T2550>) (int) D.21593;
  void * D.21597;
  void * D.21599;
  long unsigned int D.21602;
  long unsigned int D.21603;
  long unsigned int D.21606;
  long unsigned int D.21607;
  long unsigned int D.21608;
  unsigned int D.21611;
  unsigned int D.21612;
  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.19332>;
      <D.19331>:
      {
        struct MonoClass * iface;
        int interface_offset;
        int method_slot_in_interface;
        int vt_slot;

        D.21525 = klass->interfaces_packed;
        D.21526 = (long unsigned int) i;
        D.21527 = D.21526 * 8;
        D.21528 = D.21525 + D.21527;
        iface = *D.21528;
        D.21529 = klass->interface_offsets_packed;
        D.21526 = (long unsigned int) i;
        D.21530 = D.21526 * 2;
        D.21531 = D.21529 + D.21530;
        D.21532 = *D.21531;
        interface_offset = (int) D.21532;
        D.21533 = mono_class_has_variant_generic_params (iface);
        if (D.21533 != 0) goto <D.21534>; else goto <D.21535>;
        <D.21534>:
        has_variant_iface = 1;
        <D.21535>:
        mono_class_setup_methods (iface);
        vt_slot = interface_offset;
        method_slot_in_interface = 0;
        goto <D.19329>;
        <D.19328>:
        {
          struct MonoMethod * method;

          if (slot_num >= 0) goto <D.21536>; else goto <D.21537>;
          <D.21536>:
          D.21538 = BIT_FIELD_REF <*iface, 8, 288>;
          D.21539 = D.21538 & 8;
          if (D.21539 != 0) goto <D.21540>; else goto <D.21541>;
          <D.21540>:
          D.21542 = iface->generic_class;
          D.21543 = D.21542->container_class;
          method = mono_class_get_method_by_index (D.21543, method_slot_in_interface);
          D.21544 = mono_method_get_imt_slot (method);
          slot_num.31 = (unsigned int) slot_num;
          if (D.21544 != slot_num.31) goto <D.21546>; else goto <D.21547>;
          <D.21546>:
          vt_slot = vt_slot + 1;
          // predicted unlikely by continue predictor.
          goto <D.19327>;
          <D.21547>:
          <D.21541>:
          <D.21537>:
          method = mono_class_get_method_by_index (iface, method_slot_in_interface);
          D.21548 = BIT_FIELD_REF <*method, 8, 264>;
          D.21549 = D.21548 & 8;
          if (D.21549 != 0) goto <D.21550>; else goto <D.21551>;
          <D.21550>:
          has_generic_virtual = 1;
          vt_slot = vt_slot + 1;
          // predicted unlikely by continue predictor.
          goto <D.19327>;
          <D.21551>:
          D.21552 = method->flags;
          D.21553 = (int) D.21552;
          D.21554 = D.21553 & 16;
          if (D.21554 == 0) goto <D.21555>; else goto <D.21556>;
          <D.21555>:
          add_imt_builder_entry (imt_builder, method, &imt_collisions_bitmap, vt_slot, slot_num);
          vt_slot = vt_slot + 1;
          <D.21556>:
        }
        <D.19327>:
        method_slot_in_interface = method_slot_in_interface + 1;
        <D.19329>:
        method_slot_in_interface.32 = (unsigned int) method_slot_in_interface;
        D.21558 = iface->method.count;
        if (method_slot_in_interface.32 < D.21558) goto <D.19328>; else goto <D.19330>;
        <D.19330>:
      }
      i = i + 1;
      <D.19332>:
      D.21559 = klass->interface_offsets_count;
      D.21560 = (int) D.21559;
      if (D.21560 > i) goto <D.19331>; else goto <D.19333>;
      <D.19333>:
      if (extra_interfaces != 0B) goto <D.21561>; else goto <D.21562>;
      <D.21561>:
      {
        int interface_offset;

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

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

            method = mono_class_get_method_by_index (iface, method_slot_in_interface);
            D.21563 = interface_offset + method_slot_in_interface;
            add_imt_builder_entry (imt_builder, method, &imt_collisions_bitmap, D.21563, slot_num);
          }
          method_slot_in_interface = method_slot_in_interface + 1;
          <D.19339>:
          method_slot_in_interface.33 = (unsigned int) method_slot_in_interface;
          D.21565 = iface->method.count;
          if (method_slot_in_interface.33 < D.21565) goto <D.19338>; else goto <D.19340>;
          <D.19340>:
          D.21565 = iface->method.count;
          interface_offset.34 = (unsigned int) interface_offset;
          D.21567 = D.21565 + interface_offset.34;
          interface_offset = (int) D.21567;
        }
        list_item = list_item->next;
        <D.19342>:
        if (list_item != 0B) goto <D.19341>; else goto <D.19343>;
        <D.19343>:
      }
      <D.21562>:
      i = 0;
      goto <D.19351>;
      <D.19350>:
      D.21568 = slot_num < 0;
      D.21569 = i == slot_num;
      D.21570 = D.21568 | D.21569;
      if (D.21570 != 0) goto <D.21571>; else goto <D.21572>;
      <D.21571>:
      {
        struct MonoImtBuilderEntry * entries;

        D.21526 = (long unsigned int) i;
        D.21527 = D.21526 * 8;
        D.21573 = imt + D.21527;
        entries = get_generic_virtual_entries (domain, D.21573);
        if (entries != 0B) goto <D.21574>; else goto <D.21575>;
        <D.21574>:
        D.21526 = (long unsigned int) i;
        D.21527 = D.21526 * 8;
        D.21576 = imt_builder + D.21527;
        D.21577 = *D.21576;
        if (D.21577 != 0B) goto <D.21578>; else goto <D.21579>;
        <D.21578>:
        {
          struct MonoImtBuilderEntry * entry;

          entry = entries;
          goto <D.19347>;
          <D.19346>:
          entry = entry->next;
          <D.19347>:
          D.21580 = entry->next;
          if (D.21580 != 0B) goto <D.19346>; else goto <D.19348>;
          <D.19348>:
          D.21526 = (long unsigned int) i;
          D.21527 = D.21526 * 8;
          D.21576 = imt_builder + D.21527;
          D.21577 = *D.21576;
          entry->next = D.21577;
          D.21581 = entries->children;
          D.21526 = (long unsigned int) i;
          D.21527 = D.21526 * 8;
          D.21576 = imt_builder + D.21527;
          D.21577 = *D.21576;
          D.21582 = D.21577->children;
          D.21583 = D.21582 + 1;
          D.21584 = D.21581 + D.21583;
          entries->children = D.21584;
        }
        <D.21579>:
        D.21526 = (long unsigned int) i;
        D.21527 = D.21526 * 8;
        D.21576 = imt_builder + D.21527;
        *D.21576 = entries;
        <D.21575>:
        D.21585 = has_generic_virtual | has_variant_iface;
        if (D.21585 != 0) goto <D.21586>; else goto <D.21587>;
        <D.21586>:
        D.21588 = 1 << i;
        D.21589 = (unsigned int) D.21588;
        imt_collisions_bitmap.35 = imt_collisions_bitmap;
        imt_collisions_bitmap.36 = D.21589 | imt_collisions_bitmap.35;
        imt_collisions_bitmap = imt_collisions_bitmap.36;
        D.21526 = (long unsigned int) i;
        D.21527 = D.21526 * 8;
        D.21573 = imt + D.21527;
        D.21593 = callbacks.get_imt_trampoline;
        if (D.21593 != 0B) goto <D.21594>; else goto <D.21595>;
        <D.21594>:
        D.21593 = callbacks.get_imt_trampoline;
        iftmp.37 = D.21593 (i);
        goto <D.21596>;
        <D.21595>:
        iftmp.37 = 0B;
        <D.21596>:
        D.21526 = (long unsigned int) i;
        D.21527 = D.21526 * 8;
        D.21576 = imt_builder + D.21527;
        D.21577 = *D.21576;
        D.21597 = initialize_imt_slot (vt, domain, D.21577, iftmp.37);
        *D.21573 = D.21597;
        goto <D.21598>;
        <D.21587>:
        D.21526 = (long unsigned int) i;
        D.21527 = D.21526 * 8;
        D.21573 = imt + D.21527;
        D.21526 = (long unsigned int) i;
        D.21527 = D.21526 * 8;
        D.21576 = imt_builder + D.21527;
        D.21577 = *D.21576;
        D.21599 = initialize_imt_slot (vt, domain, D.21577, 0B);
        *D.21573 = D.21599;
        <D.21598>:
      }
      <D.21572>:
      D.21526 = (long unsigned int) i;
      D.21527 = D.21526 * 8;
      D.21576 = imt_builder + D.21527;
      D.21577 = *D.21576;
      if (D.21577 != 0B) goto <D.21600>; else goto <D.21601>;
      <D.21600>:
      {
        int methods_in_slot;

        D.21526 = (long unsigned int) i;
        D.21527 = D.21526 * 8;
        D.21576 = imt_builder + D.21527;
        D.21577 = *D.21576;
        D.21582 = D.21577->children;
        methods_in_slot = D.21582 + 1;
        D.21602 = (long unsigned int) methods_in_slot;
        D.21603 = mono_stats.imt_max_collisions_in_slot;
        if (D.21602 > D.21603) goto <D.21604>; else goto <D.21605>;
        <D.21604>:
        D.21602 = (long unsigned int) methods_in_slot;
        mono_stats.imt_max_collisions_in_slot = D.21602;
        record_method_count_for_max_collisions = 1;
        <D.21605>:
        method_count = method_count + methods_in_slot;
      }
      <D.21601>:
      i = i + 1;
      <D.19351>:
      if (i <= 18) goto <D.19350>; else goto <D.19352>;
      <D.19352>:
      D.21606 = mono_stats.imt_number_of_methods;
      D.21607 = (long unsigned int) method_count;
      D.21608 = D.21606 + D.21607;
      mono_stats.imt_number_of_methods = D.21608;
      if (record_method_count_for_max_collisions != 0) goto <D.21609>; else goto <D.21610>;
      <D.21609>:
      D.21607 = (long unsigned int) method_count;
      mono_stats.imt_method_count_when_max_collisions = D.21607;
      <D.21610>:
      i = 0;
      goto <D.19359>;
      <D.19358>:
      {
        struct MonoImtBuilderEntry * entry;

        D.21526 = (long unsigned int) i;
        D.21527 = D.21526 * 8;
        D.21576 = imt_builder + D.21527;
        entry = *D.21576;
        goto <D.19356>;
        <D.19355>:
        {
          struct MonoImtBuilderEntry * next;

          next = entry->next;
          monoeg_g_free (entry);
          entry = next;
        }
        <D.19356>:
        if (entry != 0B) goto <D.19355>; else goto <D.19357>;
        <D.19357>:
      }
      i = i + 1;
      <D.19359>:
      if (i <= 18) goto <D.19358>; else goto <D.19360>;
      <D.19360>:
      free (imt_builder);
      D.21611 = vt->imt_collisions_bitmap;
      imt_collisions_bitmap.35 = imt_collisions_bitmap;
      D.21612 = D.21611 | imt_collisions_bitmap.35;
      vt->imt_collisions_bitmap = D.21612;
    }
  finally
    {
      imt_collisions_bitmap = {CLOBBER};
    }
}


add_imt_builder_entry (struct MonoImtBuilderEntry * * imt_builder, struct MonoMethod * method, guint32 * imt_collisions_bitmap, int vtable_slot, int slot_num)
{
  _Bool D.21613;
  unsigned int slot_num.38;
  _Bool D.21615;
  _Bool D.21616;
  long unsigned int D.21619;
  long unsigned int D.21620;
  struct MonoImtBuilderEntry * * D.21621;
  struct MonoImtBuilderEntry * D.21622;
  int D.21625;
  int D.21626;
  int D.21627;
  long unsigned int D.21630;
  long unsigned int D.21631;
  unsigned int D.21632;
  int imt_slot.39;
  int D.21634;
  unsigned int D.21635;
  unsigned int D.21636;
  long unsigned int D.21638;
  long unsigned int D.21639;
  guint32 imt_slot;
  struct MonoImtBuilderEntry * entry;

  imt_slot = mono_method_get_imt_slot (method);
  D.21613 = slot_num >= 0;
  slot_num.38 = (unsigned int) slot_num;
  D.21615 = slot_num.38 != imt_slot;
  D.21616 = D.21613 & D.21615;
  if (D.21616 != 0) goto <D.21617>; else goto <D.21618>;
  <D.21617>:
  return;
  <D.21618>:
  entry = monoeg_malloc0 (32);
  entry->key = method;
  entry->value.vtable_slot = vtable_slot;
  D.21619 = (long unsigned int) imt_slot;
  D.21620 = D.21619 * 8;
  D.21621 = imt_builder + D.21620;
  D.21622 = *D.21621;
  entry->next = D.21622;
  D.21619 = (long unsigned int) imt_slot;
  D.21620 = D.21619 * 8;
  D.21621 = imt_builder + D.21620;
  D.21622 = *D.21621;
  if (D.21622 != 0B) goto <D.21623>; else goto <D.21624>;
  <D.21623>:
  D.21619 = (long unsigned int) imt_slot;
  D.21620 = D.21619 * 8;
  D.21621 = imt_builder + D.21620;
  D.21622 = *D.21621;
  D.21625 = D.21622->children;
  D.21626 = D.21625 + 1;
  entry->children = D.21626;
  D.21627 = entry->children;
  if (D.21627 == 1) goto <D.21628>; else goto <D.21629>;
  <D.21628>:
  D.21630 = mono_stats.imt_slots_with_collisions;
  D.21631 = D.21630 + 1;
  mono_stats.imt_slots_with_collisions = D.21631;
  D.21632 = *imt_collisions_bitmap;
  imt_slot.39 = (int) imt_slot;
  D.21634 = 1 << imt_slot.39;
  D.21635 = (unsigned int) D.21634;
  D.21636 = D.21632 | D.21635;
  *imt_collisions_bitmap = D.21636;
  <D.21629>:
  goto <D.21637>;
  <D.21624>:
  entry->children = 0;
  D.21638 = mono_stats.imt_used_slots;
  D.21639 = D.21638 + 1;
  mono_stats.imt_used_slots = D.21639;
  <D.21637>:
  D.21619 = (long unsigned int) imt_slot;
  D.21620 = D.21619 * 8;
  D.21621 = imt_builder + D.21620;
  *D.21621 = entry;
}


get_generic_virtual_entries (struct MonoDomain * domain, void * * vtable_slot)
{
  union mono_mutex_t * D.21641;
  _Bool D.21644;
  long int D.21645;
  long int D.21646;
  struct GHashTable * D.21649;
  struct GHashTable * D.21652;
  int D.21653;
  struct MonoMethod * D.21656;
  void * D.21657;
  void * D.21658;
  int D.21661;
  int D.21662;
  _Bool D.21665;
  long int D.21666;
  long int D.21667;
  struct MonoImtBuilderEntry * D.21670;
  struct GenericVirtualCase * list;
  struct MonoImtBuilderEntry * entries;

  {
    int ret;

    D.21641 = &domain->lock.mutex;
    ret = pthread_mutex_lock (D.21641);
    if (ret != 0) goto <D.21642>; else goto <D.21643>;
    <D.21642>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
    <D.21643>:
    D.21644 = ret != 0;
    D.21645 = (long int) D.21644;
    D.21646 = __builtin_expect (D.21645, 0);
    if (D.21646 != 0) goto <D.21647>; else goto <D.21648>;
    <D.21647>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 1645, "ret == 0");
    <D.21648>:
  }
  D.21649 = domain->generic_virtual_cases;
  if (D.21649 == 0B) goto <D.21650>; else goto <D.21651>;
  <D.21650>:
  D.21652 = monoeg_g_hash_table_new (mono_aligned_addr_hash, 0B);
  domain->generic_virtual_cases = D.21652;
  <D.21651>:
  D.21649 = domain->generic_virtual_cases;
  list = monoeg_g_hash_table_lookup (D.21649, vtable_slot);
  entries = 0B;
  goto <D.19436>;
  <D.19435>:
  {
    struct MonoImtBuilderEntry * entry;

    D.21653 = list->count;
    if (D.21653 <= 9) goto <D.21654>; else goto <D.21655>;
    <D.21654>:
    // predicted unlikely by continue predictor.
    goto <D.19434>;
    <D.21655>:
    entry = monoeg_malloc0 (32);
    D.21656 = list->method;
    entry->key = D.21656;
    D.21657 = list->code;
    D.21658 = mono_get_addr_from_ftnptr (D.21657);
    entry->value.target_code = D.21658;
    entry->has_target_code = 1;
    if (entries != 0B) goto <D.21659>; else goto <D.21660>;
    <D.21659>:
    D.21661 = entries->children;
    D.21662 = D.21661 + 1;
    entry->children = D.21662;
    <D.21660>:
    entry->next = entries;
    entries = entry;
  }
  <D.19434>:
  list = list->next;
  <D.19436>:
  if (list != 0B) goto <D.19435>; else goto <D.19437>;
  <D.19437>:
  {
    int ret;

    D.21641 = &domain->lock.mutex;
    ret = pthread_mutex_unlock (D.21641);
    if (ret != 0) goto <D.21663>; else goto <D.21664>;
    <D.21663>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.21664>:
    D.21665 = ret != 0;
    D.21666 = (long int) D.21665;
    D.21667 = __builtin_expect (D.21666, 0);
    if (D.21667 != 0) goto <D.21668>; else goto <D.21669>;
    <D.21668>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 1668, "ret == 0");
    <D.21669>:
  }
  D.21670 = entries;
  return D.21670;
}


initialize_imt_slot (struct MonoVTable * vtable, struct MonoDomain * domain, struct MonoImtBuilderEntry * imt_builder_entry, void * fail_tramp)
{
  int D.21675;
  void * D.21678;
  int D.21679;
  void * (*<T2788>) (struct MonoVTable *, struct MonoDomain *, struct MonoIMTCheckItem * *, int, void *) imt_thunk_builder.40;
  unsigned int D.21681;
  int D.21682;
  void * * D.21683;
  long unsigned int D.21684;
  long unsigned int D.21685;
  void * * D.21686;
  void * D.21687;
  unsigned int i.41;

  if (imt_builder_entry != 0B) goto <D.21672>; else goto <D.21673>;
  <D.21672>:
  D.21675 = imt_builder_entry->children;
  if (D.21675 == 0) goto <D.21676>; else goto <D.21674>;
  <D.21676>:
  if (fail_tramp == 0B) goto <D.21677>; else goto <D.21674>;
  <D.21677>:
  D.21679 = imt_builder_entry->value.vtable_slot;
  D.21678 = vtable->vtable[D.21679];
  return D.21678;
  <D.21674>:
  {
    struct GPtrArray * imt_ir;
    void * result;
    int i;

    imt_ir = imt_sort_slot_entries (imt_builder_entry);
    imt_thunk_builder.40 = imt_thunk_builder;
    D.21681 = imt_ir->len;
    D.21682 = (int) D.21681;
    D.21683 = imt_ir->pdata;
    result = imt_thunk_builder.40 (vtable, domain, D.21683, D.21682, fail_tramp);
    i = 0;
    goto <D.19301>;
    <D.19300>:
    D.21683 = imt_ir->pdata;
    D.21684 = (long unsigned int) i;
    D.21685 = D.21684 * 8;
    D.21686 = D.21683 + D.21685;
    D.21687 = *D.21686;
    monoeg_g_free (D.21687);
    i = i + 1;
    <D.19301>:
    i.41 = (unsigned int) i;
    D.21681 = imt_ir->len;
    if (i.41 < D.21681) goto <D.19300>; else goto <D.19302>;
    <D.19302>:
    monoeg_g_ptr_array_free (imt_ir, 1);
    D.21678 = result;
    return D.21678;
  }
  <D.21673>:
  if (fail_tramp != 0B) goto <D.21689>; else goto <D.21690>;
  <D.21689>:
  D.21678 = fail_tramp;
  return D.21678;
  <D.21690>:
  D.21678 = 0B;
  return D.21678;
}


imt_sort_slot_entries (struct MonoImtBuilderEntry * entries)
{
  int D.21692;
  long unsigned int D.21693;
  long unsigned int D.21694;
  long unsigned int D.21695;
  long unsigned int D.21696;
  struct MonoImtBuilderEntry * * D.21697;
  long unsigned int D.21698;
  struct GPtrArray * D.21699;
  int number_of_entries;
  struct MonoImtBuilderEntry * * sorted_array;
  struct GPtrArray * result;
  struct MonoImtBuilderEntry * current_entry;
  int i;

  D.21692 = entries->children;
  number_of_entries = D.21692 + 1;
  D.21693 = (long unsigned int) number_of_entries;
  D.21694 = D.21693 * 8;
  sorted_array = malloc (D.21694);
  result = monoeg_g_ptr_array_new ();
  current_entry = entries;
  i = 0;
  goto <D.19289>;
  <D.19288>:
  D.21695 = (long unsigned int) i;
  D.21696 = D.21695 * 8;
  D.21697 = sorted_array + D.21696;
  *D.21697 = current_entry;
  current_entry = current_entry->next;
  i = i + 1;
  <D.19289>:
  if (current_entry != 0B) goto <D.19288>; else goto <D.19290>;
  <D.19290>:
  D.21698 = (long unsigned int) number_of_entries;
  qsort (sorted_array, D.21698, 8, compare_imt_builder_entries);
  imt_emit_ir (sorted_array, 0, number_of_entries, result);
  free (sorted_array);
  D.21699 = result;
  return D.21699;
}


compare_imt_builder_entries (const void * p1, const void * p2)
{
  int D.21701;
  int iftmp.42;
  void * D.21703;
  void * D.21704;
  _Bool D.21707;
  struct MonoImtBuilderEntry * e1;
  struct MonoImtBuilderEntry * e2;

  e1 = MEM[(struct MonoImtBuilderEntry * *)p1];
  e2 = MEM[(struct MonoImtBuilderEntry * *)p2];
  D.21703 = e1->key;
  D.21704 = e2->key;
  if (D.21703 >= D.21704) goto <D.21705>; else goto <D.21706>;
  <D.21705>:
  D.21703 = e1->key;
  D.21704 = e2->key;
  D.21707 = D.21703 > D.21704;
  iftmp.42 = (int) D.21707;
  goto <D.21708>;
  <D.21706>:
  iftmp.42 = -1;
  <D.21708>:
  D.21701 = iftmp.42;
  return D.21701;
}


imt_emit_ir (struct MonoImtBuilderEntry * * sorted_array, int start, int end, struct GPtrArray * out_array)
{
  unsigned int D.21710;
  long unsigned int D.21713;
  long unsigned int D.21714;
  struct MonoImtBuilderEntry * * D.21715;
  struct MonoImtBuilderEntry * D.21716;
  void * D.21717;
  <unnamed-unsigned:1> D.21718;
  unsigned char D.21719;
  int D.21720;
  unsigned int D.21723;
  int D.21724;
  int D.21727;
  long unsigned int D.21728;
  long unsigned int D.21729;
  struct MonoImtBuilderEntry * * D.21730;
  struct MonoImtBuilderEntry * D.21731;
  void * D.21732;
  int D.21733;
  int D.21734;
  int count;
  int chunk_start;

  count = end - start;
  D.21710 = out_array->len;
  chunk_start = (int) D.21710;
  if (count <= 3) goto <D.21711>; else goto <D.21712>;
  <D.21711>:
  {
    int i;

    i = start;
    goto <D.19276>;
    <D.19275>:
    {
      struct MonoIMTCheckItem * item;

      item = monoeg_malloc0 (48);
      D.21713 = (long unsigned int) i;
      D.21714 = D.21713 * 8;
      D.21715 = sorted_array + D.21714;
      D.21716 = *D.21715;
      D.21717 = D.21716->key;
      item->key = D.21717;
      D.21713 = (long unsigned int) i;
      D.21714 = D.21713 * 8;
      D.21715 = sorted_array + D.21714;
      D.21716 = *D.21715;
      item->value = D.21716->value;
      D.21713 = (long unsigned int) i;
      D.21714 = D.21713 * 8;
      D.21715 = sorted_array + D.21714;
      D.21716 = *D.21715;
      D.21718 = D.21716->has_target_code;
      D.21719 = (unsigned char) D.21718;
      item->has_target_code = D.21719;
      item->is_equals = 1;
      D.21720 = end + -1;
      if (D.21720 > i) goto <D.21721>; else goto <D.21722>;
      <D.21721>:
      D.21710 = out_array->len;
      D.21723 = D.21710 + 1;
      D.21724 = (int) D.21723;
      item->check_target_idx = D.21724;
      goto <D.21725>;
      <D.21722>:
      item->check_target_idx = 0;
      <D.21725>:
      monoeg_g_ptr_array_add (out_array, item);
    }
    i = i + 1;
    <D.19276>:
    if (i < end) goto <D.19275>; else goto <D.19277>;
    <D.19277>:
  }
  goto <D.21726>;
  <D.21712>:
  {
    int middle;
    struct MonoIMTCheckItem * item;

    D.21727 = count / 2;
    middle = D.21727 + start;
    item = monoeg_malloc0 (48);
    D.21728 = (long unsigned int) middle;
    D.21729 = D.21728 * 8;
    D.21730 = sorted_array + D.21729;
    D.21731 = *D.21730;
    D.21732 = D.21731->key;
    item->key = D.21732;
    item->is_equals = 0;
    monoeg_g_ptr_array_add (out_array, item);
    imt_emit_ir (sorted_array, start, middle, out_array);
    D.21733 = imt_emit_ir (sorted_array, middle, end, out_array);
    item->check_target_idx = D.21733;
  }
  <D.21726>:
  D.21734 = chunk_start;
  return D.21734;
}


mono_method_alloc_generic_virtual_thunk (struct MonoDomain * domain, int size)
{
  unsigned int size.43;
  unsigned int D.21737;
  unsigned int size.44;
  struct MonoThunkFreeList * * D.21741;
  long unsigned int D.21742;
  long unsigned int D.21743;
  struct MonoThunkFreeList * D.21744;
  unsigned int D.21745;
  unsigned int size.45;
  struct _MonoThunkFreeList * D.21749;
  void * D.21750;
  struct MonoThunkFreeList * * D.21751;
  unsigned int D.21754;
  _Bool D.21755;
  long int D.21756;
  long int D.21757;
  struct _MonoThunkFreeList * D.21760;
  int inited.46;
  int generic_virtual_thunks_size.47;
  int generic_virtual_thunks_size.48;
  union mono_mutex_t * D.21766;
  _Bool D.21769;
  long int D.21770;
  long int D.21771;
  struct GHashTable * D.21774;
  struct GHashTable * D.21777;
  _Bool D.21780;
  long int D.21781;
  long int D.21782;
  static gboolean inited = 0;
  static int generic_virtual_thunks_size = 0;
  guint32 * p;
  int i;
  struct MonoThunkFreeList * * l;

  init_thunk_free_lists (domain);
  size.43 = (unsigned int) size;
  D.21737 = size.43 + 4;
  size = (int) D.21737;
  size.44 = (unsigned int) size;
  if (size.44 <= 15) goto <D.21739>; else goto <D.21740>;
  <D.21739>:
  size = 16;
  <D.21740>:
  i = list_index_for_size (size);
  D.21741 = domain->thunk_free_lists;
  D.21742 = (long unsigned int) i;
  D.21743 = D.21742 * 8;
  l = D.21741 + D.21743;
  goto <D.19397>;
  <D.19396>:
  D.21744 = *l;
  D.21745 = D.21744->size;
  size.45 = (unsigned int) size;
  if (D.21745 >= size.45) goto <D.21747>; else goto <D.21748>;
  <D.21747>:
  {
    struct MonoThunkFreeList * item;

    item = *l;
    D.21749 = item->next;
    *l = D.21749;
    D.21750 = item + 4;
    return D.21750;
  }
  <D.21748>:
  D.21744 = *l;
  l = &D.21744->next;
  <D.19397>:
  D.21744 = *l;
  if (D.21744 != 0B) goto <D.19396>; else goto <D.19398>;
  <D.19398>:
  goto <D.19400>;
  <D.19401>:
  {
    struct MonoThunkFreeList * item;

    D.21741 = domain->thunk_free_lists;
    D.21742 = (long unsigned int) i;
    D.21743 = D.21742 * 8;
    D.21751 = D.21741 + D.21743;
    item = *D.21751;
    if (item == 0B) goto <D.21752>; else goto <D.21753>;
    <D.21752>:
    // predicted unlikely by continue predictor.
    goto <D.19400>;
    <D.21753>:
    D.21754 = item->size;
    size.45 = (unsigned int) size;
    D.21755 = D.21754 <= size.45;
    D.21756 = (long int) D.21755;
    D.21757 = __builtin_expect (D.21756, 0);
    if (D.21757 != 0) goto <D.21758>; else goto <D.21759>;
    <D.21758>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 1550, "item->size > size");
    <D.21759>:
    D.21741 = domain->thunk_free_lists;
    D.21742 = (long unsigned int) i;
    D.21743 = D.21742 * 8;
    D.21751 = D.21741 + D.21743;
    D.21760 = item->next;
    *D.21751 = D.21760;
    D.21750 = item + 4;
    return D.21750;
  }
  <D.19400>:
  i = i + 1;
  if (i <= 11) goto <D.19401>; else goto <D.19402>;
  <D.19402>:
  inited.46 = inited;
  if (inited.46 == 0) goto <D.21762>; else goto <D.21763>;
  <D.21762>:
  mono_counters_register ("Generic virtual thunk bytes", 2048, &generic_virtual_thunks_size);
  inited = 1;
  <D.21763>:
  generic_virtual_thunks_size.47 = generic_virtual_thunks_size;
  generic_virtual_thunks_size.48 = generic_virtual_thunks_size.47 + size;
  generic_virtual_thunks_size = generic_virtual_thunks_size.48;
  p = mono_domain_code_reserve (domain, size);
  size.45 = (unsigned int) size;
  *p = size.45;
  {
    int ret;

    D.21766 = &domain->lock.mutex;
    ret = pthread_mutex_lock (D.21766);
    if (ret != 0) goto <D.21767>; else goto <D.21768>;
    <D.21767>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
    <D.21768>:
    D.21769 = ret != 0;
    D.21770 = (long int) D.21769;
    D.21771 = __builtin_expect (D.21770, 0);
    if (D.21771 != 0) goto <D.21772>; else goto <D.21773>;
    <D.21772>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 1566, "ret == 0");
    <D.21773>:
  }
  D.21774 = domain->generic_virtual_thunks;
  if (D.21774 == 0B) goto <D.21775>; else goto <D.21776>;
  <D.21775>:
  D.21777 = monoeg_g_hash_table_new (0B, 0B);
  domain->generic_virtual_thunks = D.21777;
  <D.21776>:
  D.21774 = domain->generic_virtual_thunks;
  monoeg_g_hash_table_insert_replace (D.21774, p, p, 0);
  {
    int ret;

    D.21766 = &domain->lock.mutex;
    ret = pthread_mutex_unlock (D.21766);
    if (ret != 0) goto <D.21778>; else goto <D.21779>;
    <D.21778>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.21779>:
    D.21780 = ret != 0;
    D.21781 = (long int) D.21780;
    D.21782 = __builtin_expect (D.21781, 0);
    if (D.21782 != 0) goto <D.21783>; else goto <D.21784>;
    <D.21783>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 1570, "ret == 0");
    <D.21784>:
  }
  D.21750 = p + 4;
  return D.21750;
}


init_thunk_free_lists (struct MonoDomain * domain)
{
  struct MonoThunkFreeList * * D.21786;
  void * D.21789;

  D.21786 = domain->thunk_free_lists;
  if (D.21786 != 0B) goto <D.21787>; else goto <D.21788>;
  <D.21787>:
  return;
  <D.21788>:
  D.21789 = mono_domain_alloc0 (domain, 96);
  domain->thunk_free_lists = D.21789;
}


list_index_for_size (int item_size)
{
  _Bool D.21791;
  _Bool D.21792;
  _Bool D.21793;
  int D.21794;
  int i;
  int size;

  i = 2;
  size = 64;
  goto <D.19384>;
  <D.19383>:
  i = i + 1;
  size = size << 1;
  <D.19384>:
  D.21791 = item_size > size;
  D.21792 = i <= 10;
  D.21793 = D.21791 & D.21792;
  if (D.21793 != 0) goto <D.19383>; else goto <D.19385>;
  <D.19385>:
  D.21794 = i;
  return D.21794;
}


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.21796;
  _Bool D.21799;
  long int D.21800;
  long int D.21801;
  struct GHashTable * D.21804;
  struct GHashTable * D.21807;
  struct MonoMethod * D.21808;
  void * D.21812;
  int inited.49;
  int num_added.50;
  int num_added.51;
  int D.21818;
  int D.21819;
  long int vtable_slot.52;
  long int vtable.53;
  long int D.21826;
  long int D.21827;
  void * (*<T2550>) (int) D.21828;
  void * iftmp.54;
  void * (*<T2550>) (int) D.21831;
  void *[0:] * D.21834;
  long int D.21835;
  long int D.21836;
  long int D.21837;
  int D.21838;
  void * (*<T2788>) (struct MonoVTable *, struct MonoDomain *, struct MonoIMTCheckItem * *, int, void *) imt_thunk_builder.55;
  unsigned int D.21841;
  int D.21842;
  void * * D.21843;
  void * D.21844;
  long unsigned int D.21845;
  long unsigned int D.21846;
  void * * D.21847;
  void * D.21848;
  unsigned int i.56;
  _Bool D.21850;
  _Bool D.21851;
  _Bool D.21852;
  _Bool D.21857;
  long int D.21858;
  long int D.21859;
  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.21796 = &domain->lock.mutex;
    ret = pthread_mutex_lock (D.21796);
    if (ret != 0) goto <D.21797>; else goto <D.21798>;
    <D.21797>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
    <D.21798>:
    D.21799 = ret != 0;
    D.21800 = (long int) D.21799;
    D.21801 = __builtin_expect (D.21800, 0);
    if (D.21801 != 0) goto <D.21802>; else goto <D.21803>;
    <D.21802>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 1699, "ret == 0");
    <D.21803>:
  }
  D.21804 = domain->generic_virtual_cases;
  if (D.21804 == 0B) goto <D.21805>; else goto <D.21806>;
  <D.21805>:
  D.21807 = monoeg_g_hash_table_new (mono_aligned_addr_hash, 0B);
  domain->generic_virtual_cases = D.21807;
  <D.21806>:
  D.21804 = domain->generic_virtual_cases;
  list = monoeg_g_hash_table_lookup (D.21804, vtable_slot);
  gvc = list;
  goto <D.19456>;
  <D.19455>:
  D.21808 = gvc->method;
  if (D.21808 == method) goto <D.19454>; else goto <D.21809>;
  <D.21809>:
  gvc = gvc->next;
  <D.19456>:
  if (gvc != 0B) goto <D.19455>; else goto <D.19454>;
  <D.19454>:
  if (gvc == 0B) goto <D.21810>; else goto <D.21811>;
  <D.21810>:
  gvc = mono_domain_alloc (domain, 32);
  gvc->method = method;
  gvc->code = code;
  gvc->count = 0;
  D.21804 = domain->generic_virtual_cases;
  D.21812 = monoeg_g_hash_table_lookup (D.21804, vtable_slot);
  gvc->next = D.21812;
  D.21804 = domain->generic_virtual_cases;
  monoeg_g_hash_table_insert_replace (D.21804, vtable_slot, gvc, 0);
  inited.49 = inited;
  if (inited.49 == 0) goto <D.21814>; else goto <D.21815>;
  <D.21814>:
  mono_counters_register ("Generic virtual cases", 2048, &num_added);
  inited = 1;
  <D.21815>:
  num_added.50 = num_added;
  num_added.51 = num_added.50 + 1;
  num_added = num_added.51;
  <D.21811>:
  D.21818 = gvc->count;
  D.21819 = D.21818 + 1;
  gvc->count = D.21819;
  D.21818 = gvc->count;
  if (D.21818 == 10) goto <D.21820>; else goto <D.21821>;
  <D.21820>:
  {
    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.21822>; else goto <D.21823>;
    <D.21822>:
    {
      int displacement;
      int imt_slot;

      vtable_slot.52 = (long int) vtable_slot;
      vtable.53 = (long int) vtable;
      D.21826 = vtable_slot.52 - vtable.53;
      D.21827 = D.21826 /[ex] 8;
      displacement = (int) D.21827;
      imt_slot = displacement + 19;
      D.21828 = callbacks.get_imt_trampoline;
      imt_trampoline = D.21828 (imt_slot);
      *vtable_slot = imt_trampoline;
    }
    goto <D.21829>;
    <D.21823>:
    D.21831 = callbacks.get_vtable_trampoline;
    if (D.21831 != 0B) goto <D.21832>; else goto <D.21833>;
    <D.21832>:
    D.21831 = callbacks.get_vtable_trampoline;
    vtable_slot.52 = (long int) vtable_slot;
    D.21834 = &vtable->vtable;
    D.21835 = (long int) D.21834;
    D.21836 = vtable_slot.52 - D.21835;
    D.21837 = D.21836 /[ex] 8;
    D.21838 = (int) D.21837;
    iftmp.54 = D.21831 (D.21838);
    goto <D.21839>;
    <D.21833>:
    iftmp.54 = 0B;
    <D.21839>:
    vtable_trampoline = iftmp.54;
    entries = get_generic_virtual_entries (domain, vtable_slot);
    sorted = imt_sort_slot_entries (entries);
    imt_thunk_builder.55 = imt_thunk_builder;
    D.21841 = sorted->len;
    D.21842 = (int) D.21841;
    D.21843 = sorted->pdata;
    D.21844 = imt_thunk_builder.55 (0B, domain, D.21843, D.21842, vtable_trampoline);
    *vtable_slot = D.21844;
    goto <D.19464>;
    <D.19463>:
    {
      struct MonoImtBuilderEntry * next;

      next = entries->next;
      monoeg_g_free (entries);
      entries = next;
    }
    <D.19464>:
    if (entries != 0B) goto <D.19463>; else goto <D.19465>;
    <D.19465>:
    i = 0;
    goto <D.19467>;
    <D.19466>:
    D.21843 = sorted->pdata;
    D.21845 = (long unsigned int) i;
    D.21846 = D.21845 * 8;
    D.21847 = D.21843 + D.21846;
    D.21848 = *D.21847;
    monoeg_g_free (D.21848);
    i = i + 1;
    <D.19467>:
    i.56 = (unsigned int) i;
    D.21841 = sorted->len;
    if (i.56 < D.21841) goto <D.19466>; else goto <D.19468>;
    <D.19468>:
    monoeg_g_ptr_array_free (sorted, 1);
    <D.21829>:
    D.21850 = old_thunk != vtable_trampoline;
    D.21851 = old_thunk != imt_trampoline;
    D.21852 = D.21850 & D.21851;
    if (D.21852 != 0) goto <D.21853>; else goto <D.21854>;
    <D.21853>:
    invalidate_generic_virtual_thunk (domain, old_thunk);
    <D.21854>:
  }
  <D.21821>:
  {
    int ret;

    D.21796 = &domain->lock.mutex;
    ret = pthread_mutex_unlock (D.21796);
    if (ret != 0) goto <D.21855>; else goto <D.21856>;
    <D.21855>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.21856>:
    D.21857 = ret != 0;
    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", 1770, "ret == 0");
    <D.21861>:
  }
}


invalidate_generic_virtual_thunk (struct MonoDomain * domain, void * code)
{
  union mono_mutex_t * D.21862;
  _Bool D.21865;
  long int D.21866;
  long int D.21867;
  struct GHashTable * D.21870;
  struct GHashTable * D.21873;
  void * D.21874;
  _Bool D.21879;
  long int D.21880;
  long int D.21881;
  struct MonoThunkFreeList * * D.21886;
  struct _MonoThunkFreeList * D.21887;
  struct MonoThunkFreeList * D.21888;
  int D.21889;
  unsigned int D.21890;
  int D.21891;
  long unsigned int D.21892;
  long unsigned int D.21893;
  struct MonoThunkFreeList * * D.21894;
  struct MonoThunkFreeList * D.21895;
  int D.21897;
  struct MonoThunkFreeList * * D.21898;
  struct MonoThunkFreeList * D.21899;
  struct _MonoThunkFreeList * D.21902;
  int D.21903;
  _Bool D.21905;
  long int D.21906;
  long int D.21907;
  guint32 * p;
  struct MonoThunkFreeList * l;
  gboolean found;

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

    D.21862 = &domain->lock.mutex;
    ret = pthread_mutex_lock (D.21862);
    if (ret != 0) goto <D.21863>; else goto <D.21864>;
    <D.21863>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
    <D.21864>:
    D.21865 = ret != 0;
    D.21866 = (long int) D.21865;
    D.21867 = __builtin_expect (D.21866, 0);
    if (D.21867 != 0) goto <D.21868>; else goto <D.21869>;
    <D.21868>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 1585, "ret == 0");
    <D.21869>:
  }
  D.21870 = domain->generic_virtual_thunks;
  if (D.21870 == 0B) goto <D.21871>; else goto <D.21872>;
  <D.21871>:
  D.21873 = monoeg_g_hash_table_new (0B, 0B);
  domain->generic_virtual_thunks = D.21873;
  <D.21872>:
  D.21870 = domain->generic_virtual_thunks;
  D.21874 = monoeg_g_hash_table_lookup (D.21870, l);
  if (D.21874 != 0B) goto <D.21875>; else goto <D.21876>;
  <D.21875>:
  found = 1;
  <D.21876>:
  {
    int ret;

    D.21862 = &domain->lock.mutex;
    ret = pthread_mutex_unlock (D.21862);
    if (ret != 0) goto <D.21877>; else goto <D.21878>;
    <D.21877>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.21878>:
    D.21879 = ret != 0;
    D.21880 = (long int) D.21879;
    D.21881 = __builtin_expect (D.21880, 0);
    if (D.21881 != 0) goto <D.21882>; else goto <D.21883>;
    <D.21882>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 1590, "ret == 0");
    <D.21883>:
  }
  if (found == 0) goto <D.21884>; else goto <D.21885>;
  <D.21884>:
  return;
  <D.21885>:
  init_thunk_free_lists (domain);
  goto <D.19418>;
  <D.19417>:
  {
    struct MonoThunkFreeList * item;
    int length;
    int i;

    D.21886 = domain->thunk_free_lists;
    item = *D.21886;
    length = item->length;
    D.21886 = domain->thunk_free_lists;
    D.21887 = item->next;
    *D.21886 = D.21887;
    D.21886 = domain->thunk_free_lists;
    D.21888 = *D.21886;
    D.21889 = length + -1;
    D.21888->length = D.21889;
    D.21890 = item->size;
    D.21891 = (int) D.21890;
    i = list_index_for_size (D.21891);
    D.21886 = domain->thunk_free_lists;
    D.21892 = (long unsigned int) i;
    D.21893 = D.21892 * 8;
    D.21894 = D.21886 + D.21893;
    D.21895 = *D.21894;
    item->next = D.21895;
    D.21886 = domain->thunk_free_lists;
    D.21892 = (long unsigned int) i;
    D.21893 = D.21892 * 8;
    D.21894 = D.21886 + D.21893;
    *D.21894 = item;
  }
  <D.19418>:
  D.21886 = domain->thunk_free_lists;
  D.21888 = *D.21886;
  if (D.21888 != 0B) goto <D.21896>; else goto <D.19419>;
  <D.21896>:
  D.21886 = domain->thunk_free_lists;
  D.21888 = *D.21886;
  D.21897 = D.21888->length;
  if (D.21897 > 49) goto <D.19417>; else goto <D.19419>;
  <D.19419>:
  l->next = 0B;
  D.21886 = domain->thunk_free_lists;
  D.21898 = D.21886 + 8;
  D.21899 = *D.21898;
  if (D.21899 != 0B) goto <D.21900>; else goto <D.21901>;
  <D.21900>:
  D.21886 = domain->thunk_free_lists;
  D.21898 = D.21886 + 8;
  D.21886 = domain->thunk_free_lists;
  D.21898 = D.21886 + 8;
  D.21899 = *D.21898;
  D.21899->next = l;
  D.21902 = D.21899->next;
  *D.21898 = D.21902;
  D.21886 = domain->thunk_free_lists;
  D.21888 = *D.21886;
  D.21897 = D.21888->length;
  D.21903 = D.21897 + 1;
  D.21888->length = D.21903;
  goto <D.21904>;
  <D.21901>:
  D.21886 = domain->thunk_free_lists;
  D.21888 = *D.21886;
  D.21905 = D.21888 != 0B;
  D.21906 = (long int) D.21905;
  D.21907 = __builtin_expect (D.21906, 0);
  if (D.21907 != 0) goto <D.21908>; else goto <D.21909>;
  <D.21908>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 1618, "!domain->thunk_free_lists [0]");
  <D.21909>:
  D.21886 = domain->thunk_free_lists;
  D.21886 = domain->thunk_free_lists;
  D.21898 = D.21886 + 8;
  *D.21898 = l;
  D.21899 = *D.21898;
  *D.21886 = D.21899;
  D.21886 = domain->thunk_free_lists;
  D.21888 = *D.21886;
  D.21888->length = 1;
  <D.21904>:
}


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

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


mono_class_vtable_full (struct MonoDomain * domain, struct MonoClass * class, gboolean raise_on_error)
{
  _Bool D.21913;
  long int D.21914;
  long int D.21915;
  unsigned char D.21918;
  struct MonoException * D.21923;
  struct MonoVTable * D.21924;
  short unsigned int D.21927;
  int D.21928;
  int D.21929;
  struct MonoVTable * D.21932;
  struct MonoClassRuntimeInfo * runtime_info;

  D.21913 = class == 0B;
  D.21914 = (long int) D.21913;
  D.21915 = __builtin_expect (D.21914, 0);
  if (D.21915 != 0) goto <D.21916>; else goto <D.21917>;
  <D.21916>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 1804, "class");
  <D.21917>:
  D.21918 = class->exception_type;
  if (D.21918 != 0) goto <D.21919>; else goto <D.21920>;
  <D.21919>:
  if (raise_on_error != 0) goto <D.21921>; else goto <D.21922>;
  <D.21921>:
  D.21923 = mono_class_get_exception_for_failure (class);
  mono_raise_exception (D.21923);
  <D.21922>:
  D.21924 = 0B;
  return D.21924;
  <D.21920>:
  runtime_info = class->runtime_info;
  if (runtime_info != 0B) goto <D.21925>; else goto <D.21926>;
  <D.21925>:
  D.21927 = runtime_info->max_domain;
  D.21928 = (int) D.21927;
  D.21929 = domain->domain_id;
  if (D.21928 >= D.21929) goto <D.21930>; else goto <D.21931>;
  <D.21930>:
  D.21929 = domain->domain_id;
  D.21932 = runtime_info->domain_vtables[D.21929];
  if (D.21932 != 0B) goto <D.21933>; else goto <D.21934>;
  <D.21933>:
  D.21929 = domain->domain_id;
  D.21924 = runtime_info->domain_vtables[D.21929];
  return D.21924;
  <D.21934>:
  <D.21931>:
  <D.21926>:
  D.21924 = mono_class_create_runtime_vtable (domain, class, raise_on_error);
  return D.21924;
}


mono_class_create_runtime_vtable (struct MonoDomain * domain, struct MonoClass * class, gboolean raise_on_error)
{
  union mono_mutex_t * D.21936;
  _Bool D.21939;
  long int D.21940;
  long int D.21941;
  short unsigned int D.21946;
  int D.21947;
  int D.21948;
  struct MonoVTable * D.21951;
  _Bool D.21956;
  long int D.21957;
  long int D.21958;
  struct MonoVTable * D.21961;
  long unsigned int D.21962;
  long unsigned int D.21963;
  int D.21968;
  unsigned char D.21970;
  _Bool D.21973;
  long int D.21974;
  long int D.21975;
  struct MonoException * D.21980;
  unsigned char D.21981;
  _Bool D.21982;
  _Bool D.21983;
  _Bool D.21984;
  unsigned char D.21987;
  unsigned char D.21988;
  unsigned char D.21991;
  int D.21994;
  _Bool D.22003;
  long int D.22004;
  long int D.22005;
  struct MonoException * D.22010;
  int D.22011;
  struct MonoGenericClass * D.22014;
  struct MonoMethod * * D.22017;
  _Bool D.22024;
  long int D.22025;
  long int D.22026;
  struct MonoException * D.22031;
  int D.22032;
  void * (*<T2788>) (struct MonoVTable *, struct MonoDomain *, struct MonoIMTCheckItem * *, int, void *) imt_thunk_builder.57;
  long unsigned int D.22038;
  long unsigned int D.22039;
  unsigned int D.22040;
  short unsigned int D.22041;
  long unsigned int D.22044;
  long unsigned int D.22045;
  long unsigned int D.22046;
  long unsigned int D.22047;
  short unsigned int D.22049;
  int D.22050;
  int D.22051;
  long unsigned int D.22052;
  long unsigned int D.22053;
  long unsigned int D.22054;
  unsigned int D.22055;
  long unsigned int D.22056;
  long unsigned int D.22057;
  long unsigned int D.22058;
  long unsigned int D.22059;
  long unsigned int D.22060;
  sizetype D.22063;
  sizetype D.22065;
  sizetype D.22066;
  sizetype D.22067;
  unsigned char D.22068;
  void * D.22069;
  unsigned int D.22070;
  int D.22071;
  _Bool D.22072;
  long int D.22073;
  long int D.22074;
  unsigned char D.22077;
  <unnamed-unsigned:4> D.22078;
  unsigned char D.22081;
  unsigned char D.22082;
  int max_set.58;
  int D.22086;
  long unsigned int D.22087;
  void * D.22088;
  void * D.22089;
  void * D.22093;
  long unsigned int D.22094;
  long unsigned int D.22095;
  long unsigned int D.22096;
  struct MonoType * D.22097;
  short unsigned int D.22098;
  int D.22099;
  int D.22100;
  int D.22103;
  int D.19527;
  int iftmp.59;
  int D.19526;
  const char[9] * D.22109;
  unsigned char D.22110;
  int D.22111;
  unsigned char D.22112;
  int D.22113;
  _Bool D.22114;
  _Bool D.22115;
  _Bool D.22116;
  const unsigned char * D.22119;
  unsigned char D.22120;
  int D.22121;
  const unsigned char * D.22122;
  unsigned char D.22123;
  int D.22124;
  _Bool D.22125;
  _Bool D.22126;
  const unsigned char * D.22129;
  unsigned char D.22130;
  int D.22131;
  const unsigned char * D.22132;
  unsigned char D.22133;
  int D.22134;
  _Bool D.22135;
  _Bool D.22136;
  const unsigned char * D.22139;
  unsigned char D.22140;
  int D.22141;
  const unsigned char * D.22142;
  unsigned char D.22143;
  int D.22144;
  const char * D.22146;
  int D.22149;
  int iftmp.60;
  unsigned char D.22153;
  int D.22159;
  int D.22163;
  int max_set.61;
  int D.22168;
  int align.62;
  unsigned int align.63;
  unsigned int special_static.64;
  struct GHashTable * D.22172;
  struct GHashTable * D.22175;
  long unsigned int D.22176;
  void * D.22177;
  int D.22180;
  signed short D.22183;
  _Bool D.22184;
  long int D.22185;
  long int D.22186;
  void * D.22189;
  int D.22190;
  sizetype D.22191;
  unsigned char D.22194;
  unsigned char D.22195;
  int D.22198;
  long unsigned int D.22199;
  unsigned char D.22201;
  _Bool D.22202;
  _Bool D.22203;
  _Bool D.22204;
  int D.22205;
  _Bool D.22206;
  long int D.22207;
  long int D.22208;
  char D.22211;
  guint8 * D.22212;
  struct MonoClass * * D.22215;
  long unsigned int D.22216;
  long unsigned int D.22217;
  struct MonoClass * * D.22218;
  struct MonoClass * D.22219;
  short unsigned int D.22220;
  guint16 * D.22221;
  long unsigned int D.22222;
  guint16 * D.22223;
  short unsigned int D.22224;
  int D.22225;
  long unsigned int D.22226;
  long unsigned int D.22227;
  void * * D.22228;
  void * * D.22229;
  int D.22230;
  void * (*<T2550>) (int) D.22231;
  void * D.22234;
  struct MonoMethod * * D.22236;
  void * (*<T1de2>) (struct MonoMethod *) arch_create_jit_trampoline.65;
  void * D.22240;
  void * (*<T2550>) (int) D.22245;
  void * * D.22248;
  void * D.22249;
  struct MonoClass * D.22251;
  struct MonoType * D.22254;
  struct MonoReflectionType * D.22255;
  void * D.22256;
  struct MonoClass * D.22257;
  int D.22260;
  void * D.22265;
  void * * D.22266;
  unsigned char D.22267;
  signed char D.22268;
  _Bool D.22269;
  struct GPtrArray * D.22270;
  short unsigned int D.22274;
  int D.22275;
  int D.22279;
  long unsigned int D.22280;
  long unsigned int D.22281;
  unsigned int D.22282;
  unsigned int D.22283;
  struct MonoImage * D.22284;
  short unsigned int D.22285;
  short unsigned int D.22286;
  int D.22289;
  long unsigned int D.22290;
  long unsigned int D.22291;
  struct MonoVTable *[0:] * D.22292;
  struct MonoVTable *[0:] * D.22293;
  struct MonoReflectionType * D.22296;
  struct MonoClass * D.22297;
  int D.22300;
  void * D.22305;
  _Bool D.22308;
  long int D.22309;
  long int D.22310;
  int D.22313;
  struct MonoException * D.22320;
  struct MonoClass * D.22321;
  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.21936 = &domain->lock.mutex;
        ret = pthread_mutex_lock (D.21936);
        if (ret != 0) goto <D.21937>; else goto <D.21938>;
        <D.21937>:
        monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
        <D.21938>:
        D.21939 = ret != 0;
        D.21940 = (long int) D.21939;
        D.21941 = __builtin_expect (D.21940, 0);
        if (D.21941 != 0) goto <D.21942>; else goto <D.21943>;
        <D.21942>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 1856, "ret == 0");
        <D.21943>:
      }
      runtime_info = class->runtime_info;
      if (runtime_info != 0B) goto <D.21944>; else goto <D.21945>;
      <D.21944>:
      D.21946 = runtime_info->max_domain;
      D.21947 = (int) D.21946;
      D.21948 = domain->domain_id;
      if (D.21947 >= D.21948) goto <D.21949>; else goto <D.21950>;
      <D.21949>:
      D.21948 = domain->domain_id;
      D.21951 = runtime_info->domain_vtables[D.21948];
      if (D.21951 != 0B) goto <D.21952>; else goto <D.21953>;
      <D.21952>:
      {
        int ret;

        D.21936 = &domain->lock.mutex;
        ret = pthread_mutex_unlock (D.21936);
        if (ret != 0) goto <D.21954>; else goto <D.21955>;
        <D.21954>:
        monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
        <D.21955>:
        D.21956 = ret != 0;
        D.21957 = (long int) D.21956;
        D.21958 = __builtin_expect (D.21957, 0);
        if (D.21958 != 0) goto <D.21959>; else goto <D.21960>;
        <D.21959>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 1859, "ret == 0");
        <D.21960>:
      }
      mono_loader_unlock ();
      D.21948 = domain->domain_id;
      D.21961 = runtime_info->domain_vtables[D.21948];
      return D.21961;
      <D.21953>:
      <D.21950>:
      <D.21945>:
      D.21962 = BIT_FIELD_REF <*class, 64, 256>;
      D.21963 = D.21962 & 280375465082881;
      if (D.21963 != 1) goto <D.21964>; else goto <D.21965>;
      <D.21964>:
      D.21968 = mono_class_init (class);
      if (D.21968 == 0) goto <D.21966>; else goto <D.21969>;
      <D.21969>:
      D.21970 = class->exception_type;
      if (D.21970 != 0) goto <D.21966>; else goto <D.21967>;
      <D.21966>:
      {
        int ret;

        D.21936 = &domain->lock.mutex;
        ret = pthread_mutex_unlock (D.21936);
        if (ret != 0) goto <D.21971>; else goto <D.21972>;
        <D.21971>:
        monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
        <D.21972>:
        D.21973 = ret != 0;
        D.21974 = (long int) D.21973;
        D.21975 = __builtin_expect (D.21974, 0);
        if (D.21975 != 0) goto <D.21976>; else goto <D.21977>;
        <D.21976>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 1865, "ret == 0");
        <D.21977>:
      }
      mono_loader_unlock ();
      if (raise_on_error != 0) goto <D.21978>; else goto <D.21979>;
      <D.21978>:
      D.21980 = mono_class_get_exception_for_failure (class);
      mono_raise_exception (D.21980);
      <D.21979>:
      D.21961 = 0B;
      return D.21961;
      <D.21967>:
      <D.21965>:
      D.21981 = class->byval_arg.type;
      D.21982 = D.21981 == 20;
      D.21983 = D.21981 == 29;
      D.21984 = D.21982 | D.21983;
      if (D.21984 != 0) goto <D.21985>; else goto <D.21986>;
      <D.21985>:
      {
        struct MonoClass * element_class;

        element_class = class->element_class;
        D.21987 = BIT_FIELD_REF <*element_class, 8, 256>;
        D.21988 = D.21987 & 1;
        if (D.21988 == 0) goto <D.21989>; else goto <D.21990>;
        <D.21989>:
        mono_class_init (element_class);
        <D.21990>:
        D.21991 = element_class->exception_type;
        if (D.21991 == 0) goto <D.21992>; else goto <D.21993>;
        <D.21992>:
        D.21994 = element_class->vtable_size;
        if (D.21994 == 0) goto <D.21995>; else goto <D.21996>;
        <D.21995>:
        mono_class_setup_vtable (element_class);
        <D.21996>:
        <D.21993>:
        D.21991 = element_class->exception_type;
        if (D.21991 != 0) goto <D.21997>; else goto <D.21998>;
        <D.21997>:
        D.21970 = class->exception_type;
        if (D.21970 == 0) goto <D.21999>; else goto <D.22000>;
        <D.21999>:
        mono_class_set_failure (class, 7, 0B);
        <D.22000>:
        {
          int ret;

          D.21936 = &domain->lock.mutex;
          ret = pthread_mutex_unlock (D.21936);
          if (ret != 0) goto <D.22001>; else goto <D.22002>;
          <D.22001>:
          monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
          <D.22002>:
          D.22003 = ret != 0;
          D.22004 = (long int) D.22003;
          D.22005 = __builtin_expect (D.22004, 0);
          if (D.22005 != 0) goto <D.22006>; else goto <D.22007>;
          <D.22006>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 1887, "ret == 0");
          <D.22007>:
        }
        mono_loader_unlock ();
        if (raise_on_error != 0) goto <D.22008>; else goto <D.22009>;
        <D.22008>:
        D.22010 = mono_class_get_exception_for_failure (class);
        mono_raise_exception (D.22010);
        <D.22009>:
        D.21961 = 0B;
        return D.21961;
        <D.21998>:
      }
      <D.21986>:
      D.22011 = class->vtable_size;
      if (D.22011 == 0) goto <D.22012>; else goto <D.22013>;
      <D.22012>:
      mono_class_setup_vtable (class);
      <D.22013>:
      D.22014 = class->generic_class;
      if (D.22014 != 0B) goto <D.22015>; else goto <D.22016>;
      <D.22015>:
      D.22017 = class->vtable;
      if (D.22017 == 0B) goto <D.22018>; else goto <D.22019>;
      <D.22018>:
      mono_class_check_vtable_constraints (class, 0B);
      <D.22019>:
      <D.22016>:
      mono_class_has_finalizer (class);
      D.21970 = class->exception_type;
      if (D.21970 != 0) goto <D.22020>; else goto <D.22021>;
      <D.22020>:
      {
        int ret;

        D.21936 = &domain->lock.mutex;
        ret = pthread_mutex_unlock (D.21936);
        if (ret != 0) goto <D.22022>; else goto <D.22023>;
        <D.22022>:
        monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
        <D.22023>:
        D.22024 = ret != 0;
        D.22025 = (long int) D.22024;
        D.22026 = __builtin_expect (D.22025, 0);
        if (D.22026 != 0) goto <D.22027>; else goto <D.22028>;
        <D.22027>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 1909, "ret == 0");
        <D.22028>:
      }
      mono_loader_unlock ();
      if (raise_on_error != 0) goto <D.22029>; else goto <D.22030>;
      <D.22029>:
      D.22031 = mono_class_get_exception_for_failure (class);
      mono_raise_exception (D.22031);
      <D.22030>:
      D.21961 = 0B;
      return D.21961;
      <D.22021>:
      vtable_slots = class->vtable_size;
      D.22032 = mono_class_data_size (class);
      class_size = (guint32) D.22032;
      if (class_size != 0) goto <D.22033>; else goto <D.22034>;
      <D.22033>:
      vtable_slots = vtable_slots + 1;
      <D.22034>:
      imt_thunk_builder.57 = imt_thunk_builder;
      if (imt_thunk_builder.57 != 0B) goto <D.22036>; else goto <D.22037>;
      <D.22036>:
      D.22038 = (long unsigned int) vtable_slots;
      D.22039 = D.22038 + 7;
      D.22040 = (unsigned int) D.22039;
      vtable_size = D.22040 * 8;
      D.22041 = class->interface_offsets_count;
      if (D.22041 != 0) goto <D.22042>; else goto <D.22043>;
      <D.22042>:
      imt_table_bytes = 152;
      vtable_size = vtable_size + 152;
      D.22044 = mono_stats.imt_number_of_tables;
      D.22045 = D.22044 + 1;
      mono_stats.imt_number_of_tables = D.22045;
      D.22046 = mono_stats.imt_tables_size;
      D.22047 = D.22046 + 152;
      mono_stats.imt_tables_size = D.22047;
      <D.22043>:
      goto <D.22048>;
      <D.22037>:
      D.22049 = class->max_interface_id;
      D.22050 = (int) D.22049;
      D.22051 = D.22050 + 1;
      D.22052 = (long unsigned int) D.22051;
      D.22038 = (long unsigned int) vtable_slots;
      D.22053 = D.22052 + D.22038;
      D.22054 = D.22053 + 7;
      D.22055 = (unsigned int) D.22054;
      vtable_size = D.22055 * 8;
      <D.22048>:
      D.22056 = mono_stats.used_class_count;
      D.22057 = D.22056 + 1;
      mono_stats.used_class_count = D.22057;
      D.22058 = mono_stats.class_vtable_size;
      D.22059 = (long unsigned int) vtable_size;
      D.22060 = D.22058 + D.22059;
      mono_stats.class_vtable_size = D.22060;
      interface_offsets = mono_domain_alloc0 (domain, vtable_size);
      imt_thunk_builder.57 = imt_thunk_builder;
      if (imt_thunk_builder.57 != 0B) goto <D.22061>; else goto <D.22062>;
      <D.22061>:
      D.22063 = (sizetype) imt_table_bytes;
      vt = interface_offsets + D.22063;
      goto <D.22064>;
      <D.22062>:
      D.22049 = class->max_interface_id;
      D.22065 = (sizetype) D.22049;
      D.22066 = D.22065 + 1;
      D.22067 = D.22066 * 8;
      vt = interface_offsets + D.22067;
      <D.22064>:
      vt->klass = class;
      D.22068 = class->rank;
      vt->rank = D.22068;
      vt->domain = domain;
      mono_class_compute_gc_descriptor (class);
      D.22069 = class->gc_descr;
      vt->gc_descr = D.22069;
      D.22070 = mono_gc_get_vtable_bits (class);
      gc_bits = (int) D.22070;
      D.22071 = gc_bits & -16;
      D.22072 = D.22071 != 0;
      D.22073 = (long int) D.22072;
      D.22074 = __builtin_expect (D.22073, 0);
      if (D.22074 != 0) goto <D.22075>; else goto <D.22076>;
      <D.22075>:
      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.22076>:
      D.22077 = (unsigned char) gc_bits;
      D.22078 = (<unnamed-unsigned:4>) D.22077;
      vt->gc_bits = D.22078;
      if (class_size != 0) goto <D.22079>; else goto <D.22080>;
      <D.22079>:
      D.22081 = BIT_FIELD_REF <*class, 8, 280>;
      D.22082 = D.22081 & 16;
      if (D.22082 != 0) goto <D.22083>; else goto <D.22084>;
      <D.22083>:
      {
        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.58 = max_set;
            D.22086 = max_set.58 + 1;
            statics_gc_descr = mono_gc_make_descr_from_bitmap (bitmap, D.22086);
            D.22011 = class->vtable_size;
            D.22087 = (long unsigned int) class_size;
            D.22088 = mono_gc_alloc_fixed (D.22087, statics_gc_descr);
            vt->vtable[D.22011] = D.22088;
            D.22011 = class->vtable_size;
            D.22089 = vt->vtable[D.22011];
            mono_domain_add_class_static_data (domain, class, D.22089, 0B);
            if (&default_bitmap != bitmap) goto <D.22090>; else goto <D.22091>;
            <D.22090>:
            monoeg_g_free (bitmap);
            <D.22091>:
          }
        finally
          {
            max_set = {CLOBBER};
            default_bitmap = {CLOBBER};
          }
      }
      goto <D.22092>;
      <D.22084>:
      D.22011 = class->vtable_size;
      D.22093 = mono_domain_alloc0 (domain, class_size);
      vt->vtable[D.22011] = D.22093;
      <D.22092>:
      vt->has_static_fields = 1;
      D.22094 = mono_stats.class_static_data_size;
      D.22095 = (long unsigned int) class_size;
      D.22096 = D.22094 + D.22095;
      mono_stats.class_static_data_size = D.22096;
      <D.22080>:
      cindex = 4294967295;
      iter = 0B;
      goto <D.19518>;
      <D.19539>:
      D.22097 = field->type;
      D.22098 = D.22097->attrs;
      D.22099 = (int) D.22098;
      D.22100 = D.22099 & 16;
      if (D.22100 == 0) goto <D.22101>; else goto <D.22102>;
      <D.22101>:
      // predicted unlikely by continue predictor.
      goto <D.19518>;
      <D.22102>:
      D.22097 = field->type;
      D.22098 = D.22097->attrs;
      D.22099 = (int) D.22098;
      D.22103 = D.22099 & 1536;
      if (D.22103 != 0) goto <D.22104>; else goto <D.22105>;
      <D.22104>:
      {
        size_t __s1_len;
        size_t __s2_len;

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

          __s2 = mono_field_get_name (field);
          D.22109 = "_Deleted";
          D.22110 = MEM[(const unsigned char *)D.22109];
          D.22111 = (int) D.22110;
          D.22112 = *__s2;
          D.22113 = (int) D.22112;
          __result = D.22111 - D.22113;
          {
            D.22114 = __s2_len != 0;
            D.22115 = __result == 0;
            D.22116 = D.22114 & D.22115;
            if (D.22116 != 0) goto <D.22117>; else goto <D.22118>;
            <D.22117>:
            D.22119 = &MEM[(void *)"_Deleted" + 1B];
            D.22120 = *D.22119;
            D.22121 = (int) D.22120;
            D.22122 = __s2 + 1;
            D.22123 = *D.22122;
            D.22124 = (int) D.22123;
            __result = D.22121 - D.22124;
            D.22125 = __s2_len > 1;
            D.22115 = __result == 0;
            D.22126 = D.22125 & D.22115;
            if (D.22126 != 0) goto <D.22127>; else goto <D.22128>;
            <D.22127>:
            D.22129 = &MEM[(void *)"_Deleted" + 2B];
            D.22130 = *D.22129;
            D.22131 = (int) D.22130;
            D.22132 = __s2 + 2;
            D.22133 = *D.22132;
            D.22134 = (int) D.22133;
            __result = D.22131 - D.22134;
            D.22135 = __s2_len > 2;
            D.22115 = __result == 0;
            D.22136 = D.22135 & D.22115;
            if (D.22136 != 0) goto <D.22137>; else goto <D.22138>;
            <D.22137>:
            D.22139 = &MEM[(void *)"_Deleted" + 3B];
            D.22140 = *D.22139;
            D.22141 = (int) D.22140;
            D.22142 = __s2 + 3;
            D.22143 = *D.22142;
            D.22144 = (int) D.22143;
            __result = D.22141 - D.22144;
            <D.22138>:
            <D.22128>:
            <D.22118>:
          }
          D.19526 = __result;
        }
        iftmp.59 = -D.19526;
        goto <D.22145>;
        <D.22108>:
        D.22146 = mono_field_get_name (field);
        iftmp.59 = __builtin_strcmp (D.22146, "_Deleted");
        <D.22145>:
        D.19527 = iftmp.59;
      }
      if (D.19527 == 0) goto <D.22147>; else goto <D.22148>;
      <D.22147>:
      // predicted unlikely by continue predictor.
      goto <D.19518>;
      <D.22148>:
      <D.22105>:
      D.22097 = field->type;
      D.22098 = D.22097->attrs;
      D.22099 = (int) D.22098;
      D.22149 = D.22099 & 64;
      if (D.22149 == 0) goto <D.22150>; else goto <D.22151>;
      <D.22150>:
      {
        gint32 special_static;

        D.22081 = BIT_FIELD_REF <*class, 8, 280>;
        D.22153 = D.22081 & 32;
        if (D.22153 == 0) goto <D.22154>; else goto <D.22155>;
        <D.22154>:
        iftmp.60 = field_is_special_static (class, field);
        goto <D.22156>;
        <D.22155>:
        iftmp.60 = 0;
        <D.22156>:
        special_static = iftmp.60;
        if (special_static != 0) goto <D.22157>; else goto <D.22158>;
        <D.22157>:
        {
          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.22097 = field->type;
              D.22159 = mono_type_is_reference (D.22097);
              if (D.22159 != 0) goto <D.22160>; else goto <D.22161>;
              <D.22160>:
              default_bitmap[0] = 1;
              numbits = 1;
              bitmap = &default_bitmap;
              goto <D.22162>;
              <D.22161>:
              D.22097 = field->type;
              D.22163 = mono_type_is_struct (D.22097);
              if (D.22163 != 0) goto <D.22164>; else goto <D.22165>;
              <D.22164>:
              D.22097 = field->type;
              fclass = mono_class_from_mono_type (D.22097);
              bitmap = compute_class_bitmap (fclass, &default_bitmap, 256, -2, &max_set, 0);
              max_set.61 = max_set;
              numbits = max_set.61 + 1;
              goto <D.22167>;
              <D.22165>:
              default_bitmap[0] = 0;
              numbits = 0;
              bitmap = &default_bitmap;
              <D.22167>:
              <D.22162>:
              D.22097 = field->type;
              D.22168 = mono_type_size (D.22097, &align);
              size = (guint32) D.22168;
              align.62 = align;
              align.63 = (unsigned int) align.62;
              special_static.64 = (unsigned int) special_static;
              offset = mono_alloc_special_static_data (special_static.64, size, align.63, bitmap, numbits);
              D.22172 = domain->special_static_fields;
              if (D.22172 == 0B) goto <D.22173>; else goto <D.22174>;
              <D.22173>:
              D.22175 = monoeg_g_hash_table_new (0B, 0B);
              domain->special_static_fields = D.22175;
              <D.22174>:
              D.22176 = (long unsigned int) offset;
              D.22177 = (void *) D.22176;
              D.22172 = domain->special_static_fields;
              monoeg_g_hash_table_insert_replace (D.22172, field, D.22177, 0);
              if (&default_bitmap != bitmap) goto <D.22178>; else goto <D.22179>;
              <D.22178>:
              monoeg_g_free (bitmap);
              <D.22179>:
              field->offset = -1;
              // predicted unlikely by continue predictor.
              goto <D.19518>;
            }
          finally
            {
              align = {CLOBBER};
              default_bitmap = {CLOBBER};
              max_set = {CLOBBER};
            }
        }
        <D.22158>:
      }
      <D.22151>:
      D.22097 = field->type;
      D.22098 = D.22097->attrs;
      D.22099 = (int) D.22098;
      D.22180 = D.22099 & 256;
      if (D.22180 != 0) goto <D.22181>; else goto <D.22182>;
      <D.22181>:
      {
        struct MonoClass * fklass;
        const char * data;

        D.22097 = field->type;
        fklass = mono_class_from_mono_type (D.22097);
        data = mono_field_get_data (field);
        D.22097 = field->type;
        D.22098 = D.22097->attrs;
        D.22183 = (signed short) D.22098;
        D.22184 = D.22183 < 0;
        D.22185 = (long int) D.22184;
        D.22186 = __builtin_expect (D.22185, 0);
        if (D.22186 != 0) goto <D.22187>; else goto <D.22188>;
        <D.22187>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 2043, "!(field->type->attrs & FIELD_ATTRIBUTE_HAS_DEFAULT)");
        <D.22188>:
        D.22189 = mono_vtable_get_static_field_data (vt);
        D.22190 = field->offset;
        D.22191 = (sizetype) D.22190;
        t = D.22189 + D.22191;
        if (data == 0B) goto <D.22192>; else goto <D.22193>;
        <D.22192>:
        // predicted unlikely by continue predictor.
        goto <D.19518>;
        <D.22193>:
        D.22194 = BIT_FIELD_REF <*fklass, 8, 256>;
        D.22195 = D.22194 & 8;
        if (D.22195 != 0) goto <D.22196>; else goto <D.22197>;
        <D.22196>:
        D.22198 = mono_class_value_size (fklass, 0B);
        D.22199 = (long unsigned int) D.22198;
        memcpy (t, data, D.22199);
        goto <D.22200>;
        <D.22197>:
        D.22201 = fklass->byval_arg.type;
        D.22202 = D.22201 != 15;
        D.22203 = D.22201 != 27;
        D.22204 = D.22202 & D.22203;
        D.22205 = (int) D.22204;
        D.22206 = D.22205 != 0;
        D.22207 = (long int) D.22206;
        D.22208 = __builtin_expect (D.22207, 0);
        if (D.22208 != 0) goto <D.22209>; else goto <D.22210>;
        <D.22209>:
        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.22210>:
        D.22211 = MEM[(char *)data];
        *t = D.22211;
        <D.22200>:
        // predicted unlikely by continue predictor.
        goto <D.19518>;
      }
      <D.22182>:
      <D.19518>:
      field = mono_class_get_fields (class, &iter);
      if (field != 0B) goto <D.19539>; else goto <D.19540>;
      <D.19540>:
      D.22049 = class->max_interface_id;
      vt->max_interface_id = D.22049;
      D.22212 = class->interface_bitmap;
      vt->interface_bitmap = D.22212;
      imt_thunk_builder.57 = imt_thunk_builder;
      if (imt_thunk_builder.57 == 0B) goto <D.22213>; else goto <D.22214>;
      <D.22213>:
      i = 0;
      goto <D.19544>;
      <D.19543>:
      {
        int interface_id;
        int slot;

        D.22215 = class->interfaces_packed;
        D.22216 = (long unsigned int) i;
        D.22217 = D.22216 * 8;
        D.22218 = D.22215 + D.22217;
        D.22219 = *D.22218;
        D.22220 = D.22219->interface_id;
        interface_id = (int) D.22220;
        D.22221 = class->interface_offsets_packed;
        D.22216 = (long unsigned int) i;
        D.22222 = D.22216 * 2;
        D.22223 = D.22221 + D.22222;
        D.22224 = *D.22223;
        slot = (int) D.22224;
        D.22049 = class->max_interface_id;
        D.22050 = (int) D.22049;
        D.22225 = D.22050 - interface_id;
        D.22226 = (long unsigned int) D.22225;
        D.22227 = D.22226 * 8;
        D.22228 = interface_offsets + D.22227;
        D.22229 = &vt->vtable[slot];
        *D.22228 = D.22229;
      }
      i = i + 1;
      <D.19544>:
      D.22041 = class->interface_offsets_count;
      D.22230 = (int) D.22041;
      if (D.22230 > i) goto <D.19543>; else goto <D.19545>;
      <D.19545>:
      <D.22214>:
      D.22231 = callbacks.get_vtable_trampoline;
      if (D.22231 != 0B) goto <D.22232>; else goto <D.22233>;
      <D.22232>:
      i = 0;
      goto <D.19547>;
      <D.19546>:
      D.22231 = callbacks.get_vtable_trampoline;
      D.22234 = D.22231 (i);
      vt->vtable[i] = D.22234;
      i = i + 1;
      <D.19547>:
      D.22011 = class->vtable_size;
      if (D.22011 > i) goto <D.19546>; else goto <D.19548>;
      <D.19548>:
      goto <D.22235>;
      <D.22233>:
      mono_class_setup_vtable (class);
      i = 0;
      goto <D.19551>;
      <D.19550>:
      {
        struct MonoMethod * cm;

        D.22017 = class->vtable;
        D.22216 = (long unsigned int) i;
        D.22217 = D.22216 * 8;
        D.22236 = D.22017 + D.22217;
        cm = *D.22236;
        if (cm != 0B) goto <D.22237>; else goto <D.22238>;
        <D.22237>:
        arch_create_jit_trampoline.65 = arch_create_jit_trampoline;
        D.22240 = arch_create_jit_trampoline.65 (cm);
        vt->vtable[i] = D.22240;
        <D.22238>:
      }
      i = i + 1;
      <D.19551>:
      D.22011 = class->vtable_size;
      if (D.22011 > i) goto <D.19550>; else goto <D.19552>;
      <D.19552>:
      <D.22235>:
      imt_thunk_builder.57 = imt_thunk_builder;
      if (imt_thunk_builder.57 != 0B) goto <D.22241>; else goto <D.22242>;
      <D.22241>:
      if (imt_table_bytes != 0) goto <D.22243>; else goto <D.22244>;
      <D.22243>:
      D.22245 = callbacks.get_imt_trampoline;
      if (D.22245 != 0B) goto <D.22246>; else goto <D.22247>;
      <D.22246>:
      i = 0;
      goto <D.19554>;
      <D.19553>:
      D.22216 = (long unsigned int) i;
      D.22217 = D.22216 * 8;
      D.22248 = interface_offsets + D.22217;
      D.22245 = callbacks.get_imt_trampoline;
      D.22249 = D.22245 (i);
      *D.22248 = D.22249;
      i = i + 1;
      <D.19554>:
      if (i <= 18) goto <D.19553>; else goto <D.19555>;
      <D.19555>:
      goto <D.22250>;
      <D.22247>:
      build_imt (class, vt, domain, interface_offsets, 0B);
      <D.22250>:
      <D.22244>:
      <D.22242>:
      D.22251 = mono_defaults.monotype_class;
      if (D.22251 != class) goto <D.22252>; else goto <D.22253>;
      <D.22252>:
      D.22254 = &class->byval_arg;
      D.22255 = mono_type_get_object (domain, D.22254);
      vt->type = D.22255;
      D.22256 = vt->type;
      D.22257 = mono_object_get_class (D.22256);
      D.22251 = mono_defaults.monotype_class;
      if (D.22257 != D.22251) goto <D.22258>; else goto <D.22259>;
      <D.22258>:
      D.22260 = mono_gc_is_moving ();
      if (D.22260 != 0) goto <D.22261>; else goto <D.22262>;
      <D.22261>:
      if (0 != 0) goto <D.22263>; else goto <D.22264>;
      <D.22263>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 2114, "sizeof (vt->type) == sizeof (MonoObject*)");
      <D.22264>:
      D.22265 = mono_gc_make_root_descr_all_refs (1);
      D.22266 = &vt->type;
      mono_gc_register_root (D.22266, 8, D.22265);
      <D.22262>:
      <D.22259>:
      <D.22253>:
      D.22267 = BIT_FIELD_REF <*class, 8, 272>;
      D.22268 = (signed char) D.22267;
      D.22269 = D.22268 < 0;
      vt->remote = D.22269;
      D.22270 = domain->class_vtable_array;
      monoeg_g_ptr_array_add (D.22270, vt);
      mono_memory_barrier ();
      old_info = class->runtime_info;
      if (old_info != 0B) goto <D.22273>; else goto <D.22271>;
      <D.22273>:
      D.22274 = old_info->max_domain;
      D.22275 = (int) D.22274;
      D.21948 = domain->domain_id;
      if (D.22275 >= D.21948) goto <D.22276>; else goto <D.22271>;
      <D.22276>:
      D.21948 = domain->domain_id;
      old_info->domain_vtables[D.21948] = vt;
      goto <D.22272>;
      <D.22271>:
      {
        int new_size;

        new_size = domain->domain_id;
        if (old_info != 0B) goto <D.22277>; else goto <D.22278>;
        <D.22277>:
        D.22274 = old_info->max_domain;
        D.22279 = (int) D.22274;
        new_size = MAX_EXPR <D.22279, new_size>;
        <D.22278>:
        new_size = new_size + 1;
        i = 2;
        goto <D.19558>;
        <D.19557>:
        i = i << 1;
        <D.19558>:
        if (new_size > i) goto <D.19557>; else goto <D.19559>;
        <D.19559>:
        new_size = i;
        D.22280 = (long unsigned int) new_size;
        D.22281 = D.22280 + 1;
        D.22282 = (unsigned int) D.22281;
        D.22283 = D.22282 * 8;
        D.22284 = class->image;
        runtime_info = mono_image_alloc0 (D.22284, D.22283);
        D.22285 = (short unsigned int) new_size;
        D.22286 = D.22285 + 65535;
        runtime_info->max_domain = D.22286;
        if (old_info != 0B) goto <D.22287>; else goto <D.22288>;
        <D.22287>:
        D.22274 = old_info->max_domain;
        D.22279 = (int) D.22274;
        D.22289 = D.22279 + 1;
        D.22290 = (long unsigned int) D.22289;
        D.22291 = D.22290 * 8;
        D.22292 = &old_info->domain_vtables;
        D.22293 = &runtime_info->domain_vtables;
        memcpy (D.22293, D.22292, D.22291);
        <D.22288>:
        D.21948 = domain->domain_id;
        runtime_info->domain_vtables[D.21948] = vt;
        mono_memory_barrier ();
        class->runtime_info = runtime_info;
      }
      <D.22272>:
      D.22251 = mono_defaults.monotype_class;
      if (D.22251 == class) goto <D.22294>; else goto <D.22295>;
      <D.22294>:
      D.22254 = &class->byval_arg;
      D.22296 = mono_type_get_object (domain, D.22254);
      vt->type = D.22296;
      D.22256 = vt->type;
      D.22297 = mono_object_get_class (D.22256);
      D.22251 = mono_defaults.monotype_class;
      if (D.22297 != D.22251) goto <D.22298>; else goto <D.22299>;
      <D.22298>:
      D.22300 = mono_gc_is_moving ();
      if (D.22300 != 0) goto <D.22301>; else goto <D.22302>;
      <D.22301>:
      if (0 != 0) goto <D.22303>; else goto <D.22304>;
      <D.22303>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 2168, "sizeof (vt->type) == sizeof (MonoObject*)");
      <D.22304>:
      D.22305 = mono_gc_make_root_descr_all_refs (1);
      D.22266 = &vt->type;
      mono_gc_register_root (D.22266, 8, D.22305);
      <D.22302>:
      <D.22299>:
      <D.22295>:
      {
        int ret;

        D.21936 = &domain->lock.mutex;
        ret = pthread_mutex_unlock (D.21936);
        if (ret != 0) goto <D.22306>; else goto <D.22307>;
        <D.22306>:
        monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
        <D.22307>:
        D.22308 = ret != 0;
        D.22309 = (long int) D.22308;
        D.22310 = __builtin_expect (D.22309, 0);
        if (D.22310 != 0) goto <D.22311>; else goto <D.22312>;
        <D.22311>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 2171, "ret == 0");
        <D.22312>:
      }
      mono_loader_unlock ();
      D.22313 = mono_is_security_manager_active ();
      if (D.22313 != 0) goto <D.22314>; else goto <D.22315>;
      <D.22314>:
      D.21970 = class->exception_type;
      if (D.21970 == 2) goto <D.22316>; else goto <D.22317>;
      <D.22316>:
      if (raise_on_error != 0) goto <D.22318>; else goto <D.22319>;
      <D.22318>:
      D.22320 = mono_class_get_exception_for_failure (class);
      mono_raise_exception (D.22320);
      <D.22319>:
      <D.22317>:
      <D.22315>:
      D.22321 = class->parent;
      if (D.22321 != 0B) goto <D.22322>; else goto <D.22323>;
      <D.22322>:
      D.22321 = class->parent;
      mono_class_vtable_full (domain, D.22321, raise_on_error);
      <D.22323>:
      D.21961 = vt;
      return D.21961;
    }
  finally
    {
      iter = {CLOBBER};
    }
}


field_is_special_static (struct MonoClass * fklass, struct MonoClassField * field)
{
  gint32 D.22329;
  struct MonoMethod * D.22330;
  struct MonoImage * D.22331;
  struct MonoImage * D.22332;
  int D.19214;
  int iftmp.66;
  int D.19213;
  const char[22] * D.22338;
  unsigned char D.22339;
  int D.22340;
  unsigned char D.22341;
  int D.22342;
  _Bool D.22343;
  _Bool D.22344;
  _Bool D.22345;
  const unsigned char * D.22348;
  unsigned char D.22349;
  int D.22350;
  const unsigned char * D.22351;
  unsigned char D.22352;
  int D.22353;
  _Bool D.22354;
  _Bool D.22355;
  const unsigned char * D.22358;
  unsigned char D.22359;
  int D.22360;
  const unsigned char * D.22361;
  unsigned char D.22362;
  int D.22363;
  _Bool D.22364;
  _Bool D.22365;
  const unsigned char * D.22368;
  unsigned char D.22369;
  int D.22370;
  const unsigned char * D.22371;
  unsigned char D.22372;
  int D.22373;
  const char * D.22375;
  int D.19223;
  int iftmp.67;
  int D.19222;
  const char[23] * D.22381;
  unsigned char D.22382;
  int D.22383;
  unsigned char D.22384;
  int D.22385;
  _Bool D.22386;
  _Bool D.22387;
  _Bool D.22388;
  const unsigned char * D.22391;
  unsigned char D.22392;
  int D.22393;
  const unsigned char * D.22394;
  unsigned char D.22395;
  int D.22396;
  _Bool D.22397;
  _Bool D.22398;
  const unsigned char * D.22401;
  unsigned char D.22402;
  int D.22403;
  const unsigned char * D.22404;
  unsigned char D.22405;
  int D.22406;
  _Bool D.22407;
  _Bool D.22408;
  const unsigned char * D.22411;
  unsigned char D.22412;
  int D.22413;
  const unsigned char * D.22414;
  unsigned char D.22415;
  int D.22416;
  int D.22420;
  struct MonoCustomAttrInfo * ainfo;
  int i;

  ainfo = mono_custom_attrs_from_field (fklass, field);
  if (ainfo == 0B) goto <D.22327>; else goto <D.22328>;
  <D.22327>:
  D.22329 = 0;
  return D.22329;
  <D.22328>:
  i = 0;
  goto <D.19225>;
  <D.19224>:
  {
    struct MonoClass * klass;

    D.22330 = ainfo->attrs[i].ctor;
    klass = D.22330->klass;
    D.22331 = klass->image;
    D.22332 = mono_defaults.corlib;
    if (D.22331 == D.22332) goto <D.22333>; else goto <D.22334>;
    <D.22333>:
    {
      size_t __s1_len;
      size_t __s2_len;

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

        __s2 = klass->name;
        D.22338 = "ThreadStaticAttribute";
        D.22339 = MEM[(const unsigned char *)D.22338];
        D.22340 = (int) D.22339;
        D.22341 = *__s2;
        D.22342 = (int) D.22341;
        __result = D.22340 - D.22342;
        {
          D.22343 = __s2_len != 0;
          D.22344 = __result == 0;
          D.22345 = D.22343 & D.22344;
          if (D.22345 != 0) goto <D.22346>; else goto <D.22347>;
          <D.22346>:
          D.22348 = &MEM[(void *)"ThreadStaticAttribute" + 1B];
          D.22349 = *D.22348;
          D.22350 = (int) D.22349;
          D.22351 = __s2 + 1;
          D.22352 = *D.22351;
          D.22353 = (int) D.22352;
          __result = D.22350 - D.22353;
          D.22354 = __s2_len > 1;
          D.22344 = __result == 0;
          D.22355 = D.22354 & D.22344;
          if (D.22355 != 0) goto <D.22356>; else goto <D.22357>;
          <D.22356>:
          D.22358 = &MEM[(void *)"ThreadStaticAttribute" + 2B];
          D.22359 = *D.22358;
          D.22360 = (int) D.22359;
          D.22361 = __s2 + 2;
          D.22362 = *D.22361;
          D.22363 = (int) D.22362;
          __result = D.22360 - D.22363;
          D.22364 = __s2_len > 2;
          D.22344 = __result == 0;
          D.22365 = D.22364 & D.22344;
          if (D.22365 != 0) goto <D.22366>; else goto <D.22367>;
          <D.22366>:
          D.22368 = &MEM[(void *)"ThreadStaticAttribute" + 3B];
          D.22369 = *D.22368;
          D.22370 = (int) D.22369;
          D.22371 = __s2 + 3;
          D.22372 = *D.22371;
          D.22373 = (int) D.22372;
          __result = D.22370 - D.22373;
          <D.22367>:
          <D.22357>:
          <D.22347>:
        }
        D.19213 = __result;
      }
      iftmp.66 = -D.19213;
      goto <D.22374>;
      <D.22337>:
      D.22375 = klass->name;
      iftmp.66 = __builtin_strcmp (D.22375, "ThreadStaticAttribute");
      <D.22374>:
      D.19214 = iftmp.66;
    }
    if (D.19214 == 0) goto <D.22376>; else goto <D.22377>;
    <D.22376>:
    mono_custom_attrs_free (ainfo);
    D.22329 = 1;
    return D.22329;
    <D.22377>:
    {
      size_t __s1_len;
      size_t __s2_len;

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

        __s2 = klass->name;
        D.22381 = "ContextStaticAttribute";
        D.22382 = MEM[(const unsigned char *)D.22381];
        D.22383 = (int) D.22382;
        D.22384 = *__s2;
        D.22385 = (int) D.22384;
        __result = D.22383 - D.22385;
        {
          D.22386 = __s2_len != 0;
          D.22387 = __result == 0;
          D.22388 = D.22386 & D.22387;
          if (D.22388 != 0) goto <D.22389>; else goto <D.22390>;
          <D.22389>:
          D.22391 = &MEM[(void *)"ContextStaticAttribute" + 1B];
          D.22392 = *D.22391;
          D.22393 = (int) D.22392;
          D.22394 = __s2 + 1;
          D.22395 = *D.22394;
          D.22396 = (int) D.22395;
          __result = D.22393 - D.22396;
          D.22397 = __s2_len > 1;
          D.22387 = __result == 0;
          D.22398 = D.22397 & D.22387;
          if (D.22398 != 0) goto <D.22399>; else goto <D.22400>;
          <D.22399>:
          D.22401 = &MEM[(void *)"ContextStaticAttribute" + 2B];
          D.22402 = *D.22401;
          D.22403 = (int) D.22402;
          D.22404 = __s2 + 2;
          D.22405 = *D.22404;
          D.22406 = (int) D.22405;
          __result = D.22403 - D.22406;
          D.22407 = __s2_len > 2;
          D.22387 = __result == 0;
          D.22408 = D.22407 & D.22387;
          if (D.22408 != 0) goto <D.22409>; else goto <D.22410>;
          <D.22409>:
          D.22411 = &MEM[(void *)"ContextStaticAttribute" + 3B];
          D.22412 = *D.22411;
          D.22413 = (int) D.22412;
          D.22414 = __s2 + 3;
          D.22415 = *D.22414;
          D.22416 = (int) D.22415;
          __result = D.22413 - D.22416;
          <D.22410>:
          <D.22400>:
          <D.22390>:
        }
        D.19222 = __result;
      }
      iftmp.67 = -D.19222;
      goto <D.22417>;
      <D.22380>:
      D.22375 = klass->name;
      iftmp.67 = __builtin_strcmp (D.22375, "ContextStaticAttribute");
      <D.22417>:
      D.19223 = iftmp.67;
    }
    if (D.19223 == 0) goto <D.22418>; else goto <D.22419>;
    <D.22418>:
    mono_custom_attrs_free (ainfo);
    D.22329 = 2;
    return D.22329;
    <D.22419>:
    <D.22334>:
  }
  i = i + 1;
  <D.19225>:
  D.22420 = ainfo->num_attrs;
  if (D.22420 > i) goto <D.19224>; else goto <D.19226>;
  <D.19226>:
  mono_custom_attrs_free (ainfo);
  D.22329 = 0;
  return D.22329;
}


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


mono_class_try_get_vtable (struct MonoDomain * domain, struct MonoClass * class)
{
  _Bool D.22422;
  long int D.22423;
  long int D.22424;
  short unsigned int D.22429;
  int D.22430;
  int D.22431;
  struct MonoVTable * D.22434;
  struct MonoVTable * D.22437;
  struct MonoClassRuntimeInfo * runtime_info;

  D.22422 = class == 0B;
  D.22423 = (long int) D.22422;
  D.22424 = __builtin_expect (D.22423, 0);
  if (D.22424 != 0) goto <D.22425>; else goto <D.22426>;
  <D.22425>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 1832, "class");
  <D.22426>:
  runtime_info = class->runtime_info;
  if (runtime_info != 0B) goto <D.22427>; else goto <D.22428>;
  <D.22427>:
  D.22429 = runtime_info->max_domain;
  D.22430 = (int) D.22429;
  D.22431 = domain->domain_id;
  if (D.22430 >= D.22431) goto <D.22432>; else goto <D.22433>;
  <D.22432>:
  D.22431 = domain->domain_id;
  D.22434 = runtime_info->domain_vtables[D.22431];
  if (D.22434 != 0B) goto <D.22435>; else goto <D.22436>;
  <D.22435>:
  D.22431 = domain->domain_id;
  D.22437 = runtime_info->domain_vtables[D.22431];
  return D.22437;
  <D.22436>:
  <D.22433>:
  <D.22428>:
  D.22437 = 0B;
  return D.22437;
}


mono_class_field_is_special_static (struct MonoClassField * field)
{
  struct MonoType * D.22439;
  short unsigned int D.22440;
  int D.22441;
  int D.22442;
  gboolean D.22445;
  int D.22446;
  int D.19635;
  int iftmp.68;
  int D.19634;
  const char[9] * D.22452;
  unsigned char D.22453;
  int D.22454;
  unsigned char D.22455;
  int D.22456;
  _Bool D.22457;
  _Bool D.22458;
  _Bool D.22459;
  const unsigned char * D.22462;
  unsigned char D.22463;
  int D.22464;
  const unsigned char * D.22465;
  unsigned char D.22466;
  int D.22467;
  _Bool D.22468;
  _Bool D.22469;
  const unsigned char * D.22472;
  unsigned char D.22473;
  int D.22474;
  const unsigned char * D.22475;
  unsigned char D.22476;
  int D.22477;
  _Bool D.22478;
  _Bool D.22479;
  const unsigned char * D.22482;
  unsigned char D.22483;
  int D.22484;
  const unsigned char * D.22485;
  unsigned char D.22486;
  int D.22487;
  const char * D.22489;
  int D.22492;
  struct MonoClass * D.22495;
  int D.22496;

  D.22439 = field->type;
  D.22440 = D.22439->attrs;
  D.22441 = (int) D.22440;
  D.22442 = D.22441 & 16;
  if (D.22442 == 0) goto <D.22443>; else goto <D.22444>;
  <D.22443>:
  D.22445 = 0;
  return D.22445;
  <D.22444>:
  D.22439 = field->type;
  D.22440 = D.22439->attrs;
  D.22441 = (int) D.22440;
  D.22446 = D.22441 & 1536;
  if (D.22446 != 0) goto <D.22447>; else goto <D.22448>;
  <D.22447>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = mono_field_get_name (field);
      D.22452 = "_Deleted";
      D.22453 = MEM[(const unsigned char *)D.22452];
      D.22454 = (int) D.22453;
      D.22455 = *__s2;
      D.22456 = (int) D.22455;
      __result = D.22454 - D.22456;
      {
        D.22457 = __s2_len != 0;
        D.22458 = __result == 0;
        D.22459 = D.22457 & D.22458;
        if (D.22459 != 0) goto <D.22460>; else goto <D.22461>;
        <D.22460>:
        D.22462 = &MEM[(void *)"_Deleted" + 1B];
        D.22463 = *D.22462;
        D.22464 = (int) D.22463;
        D.22465 = __s2 + 1;
        D.22466 = *D.22465;
        D.22467 = (int) D.22466;
        __result = D.22464 - D.22467;
        D.22468 = __s2_len > 1;
        D.22458 = __result == 0;
        D.22469 = D.22468 & D.22458;
        if (D.22469 != 0) goto <D.22470>; else goto <D.22471>;
        <D.22470>:
        D.22472 = &MEM[(void *)"_Deleted" + 2B];
        D.22473 = *D.22472;
        D.22474 = (int) D.22473;
        D.22475 = __s2 + 2;
        D.22476 = *D.22475;
        D.22477 = (int) D.22476;
        __result = D.22474 - D.22477;
        D.22478 = __s2_len > 2;
        D.22458 = __result == 0;
        D.22479 = D.22478 & D.22458;
        if (D.22479 != 0) goto <D.22480>; else goto <D.22481>;
        <D.22480>:
        D.22482 = &MEM[(void *)"_Deleted" + 3B];
        D.22483 = *D.22482;
        D.22484 = (int) D.22483;
        D.22485 = __s2 + 3;
        D.22486 = *D.22485;
        D.22487 = (int) D.22486;
        __result = D.22484 - D.22487;
        <D.22481>:
        <D.22471>:
        <D.22461>:
      }
      D.19634 = __result;
    }
    iftmp.68 = -D.19634;
    goto <D.22488>;
    <D.22451>:
    D.22489 = mono_field_get_name (field);
    iftmp.68 = __builtin_strcmp (D.22489, "_Deleted");
    <D.22488>:
    D.19635 = iftmp.68;
  }
  if (D.19635 == 0) goto <D.22490>; else goto <D.22491>;
  <D.22490>:
  D.22445 = 0;
  return D.22445;
  <D.22491>:
  <D.22448>:
  D.22439 = field->type;
  D.22440 = D.22439->attrs;
  D.22441 = (int) D.22440;
  D.22492 = D.22441 & 64;
  if (D.22492 == 0) goto <D.22493>; else goto <D.22494>;
  <D.22493>:
  D.22495 = field->parent;
  D.22496 = field_is_special_static (D.22495, field);
  if (D.22496 != 0) goto <D.22497>; else goto <D.22498>;
  <D.22497>:
  D.22445 = 1;
  return D.22445;
  <D.22498>:
  <D.22494>:
  D.22445 = 0;
  return D.22445;
}


mono_class_field_get_special_static_type (struct MonoClassField * field)
{
  struct MonoType * D.22500;
  short unsigned int D.22501;
  int D.22502;
  int D.22503;
  guint32 D.22506;
  int D.22507;
  int D.19647;
  int iftmp.69;
  int D.19646;
  const char[9] * D.22513;
  unsigned char D.22514;
  int D.22515;
  unsigned char D.22516;
  int D.22517;
  _Bool D.22518;
  _Bool D.22519;
  _Bool D.22520;
  const unsigned char * D.22523;
  unsigned char D.22524;
  int D.22525;
  const unsigned char * D.22526;
  unsigned char D.22527;
  int D.22528;
  _Bool D.22529;
  _Bool D.22530;
  const unsigned char * D.22533;
  unsigned char D.22534;
  int D.22535;
  const unsigned char * D.22536;
  unsigned char D.22537;
  int D.22538;
  _Bool D.22539;
  _Bool D.22540;
  const unsigned char * D.22543;
  unsigned char D.22544;
  int D.22545;
  const unsigned char * D.22546;
  unsigned char D.22547;
  int D.22548;
  const char * D.22550;
  int D.22553;
  struct MonoClass * D.22556;
  int D.22557;

  D.22500 = field->type;
  D.22501 = D.22500->attrs;
  D.22502 = (int) D.22501;
  D.22503 = D.22502 & 16;
  if (D.22503 == 0) goto <D.22504>; else goto <D.22505>;
  <D.22504>:
  D.22506 = 0;
  return D.22506;
  <D.22505>:
  D.22500 = field->type;
  D.22501 = D.22500->attrs;
  D.22502 = (int) D.22501;
  D.22507 = D.22502 & 1536;
  if (D.22507 != 0) goto <D.22508>; else goto <D.22509>;
  <D.22508>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = mono_field_get_name (field);
      D.22513 = "_Deleted";
      D.22514 = MEM[(const unsigned char *)D.22513];
      D.22515 = (int) D.22514;
      D.22516 = *__s2;
      D.22517 = (int) D.22516;
      __result = D.22515 - D.22517;
      {
        D.22518 = __s2_len != 0;
        D.22519 = __result == 0;
        D.22520 = D.22518 & D.22519;
        if (D.22520 != 0) goto <D.22521>; else goto <D.22522>;
        <D.22521>:
        D.22523 = &MEM[(void *)"_Deleted" + 1B];
        D.22524 = *D.22523;
        D.22525 = (int) D.22524;
        D.22526 = __s2 + 1;
        D.22527 = *D.22526;
        D.22528 = (int) D.22527;
        __result = D.22525 - D.22528;
        D.22529 = __s2_len > 1;
        D.22519 = __result == 0;
        D.22530 = D.22529 & D.22519;
        if (D.22530 != 0) goto <D.22531>; else goto <D.22532>;
        <D.22531>:
        D.22533 = &MEM[(void *)"_Deleted" + 2B];
        D.22534 = *D.22533;
        D.22535 = (int) D.22534;
        D.22536 = __s2 + 2;
        D.22537 = *D.22536;
        D.22538 = (int) D.22537;
        __result = D.22535 - D.22538;
        D.22539 = __s2_len > 2;
        D.22519 = __result == 0;
        D.22540 = D.22539 & D.22519;
        if (D.22540 != 0) goto <D.22541>; else goto <D.22542>;
        <D.22541>:
        D.22543 = &MEM[(void *)"_Deleted" + 3B];
        D.22544 = *D.22543;
        D.22545 = (int) D.22544;
        D.22546 = __s2 + 3;
        D.22547 = *D.22546;
        D.22548 = (int) D.22547;
        __result = D.22545 - D.22548;
        <D.22542>:
        <D.22532>:
        <D.22522>:
      }
      D.19646 = __result;
    }
    iftmp.69 = -D.19646;
    goto <D.22549>;
    <D.22512>:
    D.22550 = mono_field_get_name (field);
    iftmp.69 = __builtin_strcmp (D.22550, "_Deleted");
    <D.22549>:
    D.19647 = iftmp.69;
  }
  if (D.19647 == 0) goto <D.22551>; else goto <D.22552>;
  <D.22551>:
  D.22506 = 0;
  return D.22506;
  <D.22552>:
  <D.22509>:
  D.22500 = field->type;
  D.22501 = D.22500->attrs;
  D.22502 = (int) D.22501;
  D.22553 = D.22502 & 64;
  if (D.22553 == 0) goto <D.22554>; else goto <D.22555>;
  <D.22554>:
  D.22556 = field->parent;
  D.22557 = field_is_special_static (D.22556, field);
  D.22506 = (guint32) D.22557;
  return D.22506;
  <D.22555>:
  D.22506 = 0;
  return D.22506;
}


mono_class_has_special_static_fields (struct MonoClass * klass)
{
  struct MonoClass * D.22559;
  _Bool D.22560;
  long int D.22561;
  long int D.22562;
  int D.22565;
  gboolean D.22568;
  struct MonoClassField * field;
  void * iter;

  try
    {
      iter = 0B;
      goto <D.19654>;
      <D.19653>:
      D.22559 = field->parent;
      D.22560 = D.22559 != klass;
      D.22561 = (long int) D.22560;
      D.22562 = __builtin_expect (D.22561, 0);
      if (D.22562 != 0) goto <D.22563>; else goto <D.22564>;
      <D.22563>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 2420, "field->parent == klass");
      <D.22564>:
      D.22565 = mono_class_field_is_special_static (field);
      if (D.22565 != 0) goto <D.22566>; else goto <D.22567>;
      <D.22566>:
      D.22568 = 1;
      return D.22568;
      <D.22567>:
      <D.19654>:
      field = mono_class_get_fields (klass, &iter);
      if (field != 0B) goto <D.19653>; else goto <D.19655>;
      <D.19655>:
      D.22568 = 0;
      return D.22568;
    }
  finally
    {
      iter = {CLOBBER};
    }
}


mono_remote_class (struct MonoDomain * domain, struct MonoString * class_name, struct MonoClass * proxy_class)
{
  union mono_mutex_t * D.22571;
  _Bool D.22574;
  long int D.22575;
  long int D.22576;
  struct GHashTable * D.22579;
  _Bool D.22584;
  long int D.22585;
  long int D.22586;
  struct MonoRemoteClass * D.22589;
  struct MonoMemPool * D.22590;
  int D.22591;
  _Bool D.22596;
  long int D.22597;
  long int D.22598;
  unsigned int D.22601;
  unsigned int D.22602;
  struct MonoClass * D.22605;
  int D.22607;
  int D.22608;
  struct MonoPerfCounters * mono_perfcounters.70;
  unsigned int D.22610;
  unsigned int D.22611;
  unsigned int D.22612;
  _Bool D.22615;
  long int D.22616;
  long int D.22617;
  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.22571 = &domain->lock.mutex;
        ret = pthread_mutex_lock (D.22571);
        if (ret != 0) goto <D.22572>; else goto <D.22573>;
        <D.22572>:
        monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
        <D.22573>:
        D.22574 = ret != 0;
        D.22575 = (long int) D.22574;
        D.22576 = __builtin_expect (D.22575, 0);
        if (D.22576 != 0) goto <D.22577>; else goto <D.22578>;
        <D.22577>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 2515, "ret == 0");
        <D.22578>:
      }
      D.22579 = domain->proxy_vtable_hash;
      rc = monoeg_g_hash_table_lookup (D.22579, key);
      if (rc != 0B) goto <D.22580>; else goto <D.22581>;
      <D.22580>:
      monoeg_g_free (key);
      {
        int ret;

        D.22571 = &domain->lock.mutex;
        ret = pthread_mutex_unlock (D.22571);
        if (ret != 0) goto <D.22582>; else goto <D.22583>;
        <D.22582>:
        monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
        <D.22583>:
        D.22584 = ret != 0;
        D.22585 = (long int) D.22584;
        D.22586 = __builtin_expect (D.22585, 0);
        if (D.22586 != 0) goto <D.22587>; else goto <D.22588>;
        <D.22587>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 2520, "ret == 0");
        <D.22588>:
      }
      D.22589 = rc;
      return D.22589;
      <D.22581>:
      D.22590 = domain->mp;
      name = mono_string_to_utf8_mp (D.22590, class_name, &error);
      D.22591 = mono_error_ok (&error);
      if (D.22591 == 0) goto <D.22592>; else goto <D.22593>;
      <D.22592>:
      monoeg_g_free (key);
      {
        int ret;

        D.22571 = &domain->lock.mutex;
        ret = pthread_mutex_unlock (D.22571);
        if (ret != 0) goto <D.22594>; else goto <D.22595>;
        <D.22594>:
        monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
        <D.22595>:
        D.22596 = ret != 0;
        D.22597 = (long int) D.22596;
        D.22598 = __builtin_expect (D.22597, 0);
        if (D.22598 != 0) goto <D.22599>; else goto <D.22600>;
        <D.22599>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 2527, "ret == 0");
        <D.22600>:
      }
      mono_error_raise_exception (&error);
      <D.22593>:
      mp_key = copy_remote_class_key (domain, key);
      monoeg_g_free (key);
      key = mp_key;
      D.22601 = proxy_class->flags;
      D.22602 = D.22601 & 32;
      if (D.22602 != 0) goto <D.22603>; else goto <D.22604>;
      <D.22603>:
      rc = mono_domain_alloc (domain, 48);
      rc->interface_count = 1;
      rc->interfaces[0] = proxy_class;
      D.22605 = mono_defaults.marshalbyrefobject_class;
      rc->proxy_class = D.22605;
      goto <D.22606>;
      <D.22604>:
      rc = mono_domain_alloc (domain, 40);
      rc->interface_count = 0;
      rc->proxy_class = proxy_class;
      <D.22606>:
      rc->default_vtable = 0B;
      rc->xdomain_vtable = 0B;
      rc->proxy_class_name = name;
      D.22607 = mono_string_length (class_name);
      D.22608 = D.22607 + 1;
      mono_perfcounters.70 = mono_perfcounters;
      mono_perfcounters.70 = mono_perfcounters;
      D.22610 = mono_perfcounters.70->loader_bytes;
      D.22611 = (unsigned int) D.22608;
      D.22612 = D.22610 + D.22611;
      mono_perfcounters.70->loader_bytes = D.22612;
      D.22579 = domain->proxy_vtable_hash;
      monoeg_g_hash_table_insert_replace (D.22579, key, rc, 0);
      {
        int ret;

        D.22571 = &domain->lock.mutex;
        ret = pthread_mutex_unlock (D.22571);
        if (ret != 0) goto <D.22613>; else goto <D.22614>;
        <D.22613>:
        monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
        <D.22614>:
        D.22615 = ret != 0;
        D.22616 = (long int) D.22615;
        D.22617 = __builtin_expect (D.22616, 0);
        if (D.22617 != 0) goto <D.22618>; else goto <D.22619>;
        <D.22618>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 2555, "ret == 0");
        <D.22619>:
      }
      D.22589 = rc;
      return D.22589;
    }
  finally
    {
      error = {CLOBBER};
    }
}


create_remote_class_key (struct MonoRemoteClass * remote_class, struct MonoClass * extra_class)
{
  unsigned int D.22624;
  unsigned int D.22625;
  void * * D.22628;
  struct MonoClass * D.22629;
  void * * D.22630;
  unsigned int D.22636;
  unsigned int D.22637;
  long unsigned int D.22638;
  long unsigned int D.22639;
  unsigned int D.22640;
  long int D.22641;
  void * D.22642;
  struct MonoClass * D.22643;
  struct MonoClass * D.22646;
  int j.71;
  long unsigned int D.22650;
  long unsigned int D.22651;
  void * * D.22652;
  long unsigned int D.22653;
  long unsigned int D.22654;
  void * * D.22655;
  unsigned int i.72;
  long unsigned int D.22659;
  long unsigned int D.22660;
  unsigned int D.22661;
  long int D.22662;
  void * D.22663;
  struct MonoClass * iftmp.73;
  int D.22668;
  long unsigned int D.22669;
  long unsigned int D.22670;
  void * * D.22671;
  void * * D.22672;
  void * * key;
  int i;
  int j;

  if (remote_class == 0B) goto <D.22622>; else goto <D.22623>;
  <D.22622>:
  D.22624 = extra_class->flags;
  D.22625 = D.22624 & 32;
  if (D.22625 != 0) goto <D.22626>; else goto <D.22627>;
  <D.22626>:
  key = monoeg_malloc (24);
  *key = 2B;
  D.22628 = key + 8;
  D.22629 = mono_defaults.marshalbyrefobject_class;
  *D.22628 = D.22629;
  D.22630 = key + 16;
  *D.22630 = extra_class;
  goto <D.22631>;
  <D.22627>:
  key = monoeg_malloc (16);
  *key = 1B;
  D.22628 = key + 8;
  *D.22628 = extra_class;
  <D.22631>:
  goto <D.22632>;
  <D.22623>:
  if (extra_class != 0B) goto <D.22634>; else goto <D.22633>;
  <D.22634>:
  D.22624 = extra_class->flags;
  D.22625 = D.22624 & 32;
  if (D.22625 != 0) goto <D.22635>; else goto <D.22633>;
  <D.22635>:
  D.22636 = remote_class->interface_count;
  D.22637 = D.22636 + 3;
  D.22638 = (long unsigned int) D.22637;
  D.22639 = D.22638 * 8;
  key = monoeg_malloc (D.22639);
  D.22636 = remote_class->interface_count;
  D.22640 = D.22636 + 2;
  D.22641 = (long int) D.22640;
  D.22642 = (void *) D.22641;
  *key = D.22642;
  D.22628 = key + 8;
  D.22643 = remote_class->proxy_class;
  *D.22628 = D.22643;
  i = 0;
  j = 2;
  goto <D.19664>;
  <D.19663>:
  if (extra_class != 0B) goto <D.22644>; else goto <D.22645>;
  <D.22644>:
  D.22646 = remote_class->interfaces[i];
  if (D.22646 > extra_class) goto <D.22647>; else goto <D.22648>;
  <D.22647>:
  j.71 = j;
  j = j.71 + 1;
  D.22650 = (long unsigned int) j.71;
  D.22651 = D.22650 * 8;
  D.22652 = key + D.22651;
  *D.22652 = extra_class;
  extra_class = 0B;
  <D.22648>:
  <D.22645>:
  D.22653 = (long unsigned int) j;
  D.22654 = D.22653 * 8;
  D.22655 = key + D.22654;
  D.22646 = remote_class->interfaces[i];
  *D.22655 = D.22646;
  i = i + 1;
  j = j + 1;
  <D.19664>:
  i.72 = (unsigned int) i;
  D.22636 = remote_class->interface_count;
  if (i.72 < D.22636) goto <D.19663>; else goto <D.19665>;
  <D.19665>:
  if (extra_class != 0B) goto <D.22657>; else goto <D.22658>;
  <D.22657>:
  D.22653 = (long unsigned int) j;
  D.22654 = D.22653 * 8;
  D.22655 = key + D.22654;
  *D.22655 = extra_class;
  <D.22658>:
  goto <D.19668>;
  <D.22633>:
  D.22636 = remote_class->interface_count;
  D.22640 = D.22636 + 2;
  D.22659 = (long unsigned int) D.22640;
  D.22660 = D.22659 * 8;
  key = monoeg_malloc (D.22660);
  D.22636 = remote_class->interface_count;
  D.22661 = D.22636 + 1;
  D.22662 = (long int) D.22661;
  D.22663 = (void *) D.22662;
  *key = D.22663;
  D.22628 = key + 8;
  if (extra_class == 0B) goto <D.22665>; else goto <D.22666>;
  <D.22665>:
  iftmp.73 = remote_class->proxy_class;
  goto <D.22667>;
  <D.22666>:
  iftmp.73 = extra_class;
  <D.22667>:
  *D.22628 = iftmp.73;
  i = 0;
  goto <D.19667>;
  <D.19666>:
  D.22668 = i + 2;
  D.22669 = (long unsigned int) D.22668;
  D.22670 = D.22669 * 8;
  D.22671 = key + D.22670;
  D.22646 = remote_class->interfaces[i];
  *D.22671 = D.22646;
  i = i + 1;
  <D.19667>:
  i.72 = (unsigned int) i;
  D.22636 = remote_class->interface_count;
  if (i.72 < D.22636) goto <D.19666>; else goto <D.19668>;
  <D.19668>:
  <D.22632>:
  D.22672 = key;
  return D.22672;
}


copy_remote_class_key (struct MonoDomain * domain, void * * key)
{
  void * D.22674;
  long int D.22675;
  unsigned int D.22676;
  unsigned int D.22677;
  unsigned int D.22678;
  unsigned int key_size.74;
  long unsigned int D.22680;
  void * * D.22681;
  int key_size;
  void * * mp_key;

  D.22674 = *key;
  D.22675 = (long int) D.22674;
  D.22676 = (unsigned int) D.22675;
  D.22677 = D.22676 + 1;
  D.22678 = D.22677 * 8;
  key_size = (int) D.22678;
  key_size.74 = (unsigned int) key_size;
  mp_key = mono_domain_alloc (domain, key_size.74);
  D.22680 = (long unsigned int) key_size;
  memcpy (mp_key, key, D.22680);
  D.22681 = mp_key;
  return D.22681;
}


mono_remote_class_vtable (struct MonoDomain * domain, struct MonoRemoteClass * remote_class, struct MonoRealProxy * rp)
{
  union mono_mutex_t * D.22683;
  _Bool D.22686;
  long int D.22687;
  long int D.22688;
  int D.22691;
  struct MonoVTable * D.22694;
  struct MonoVTable * D.22697;
  _Bool D.22700;
  long int D.22701;
  long int D.22702;
  void * D.22705;
  struct MonoVTable * D.22706;
  struct MonoReflectionType * D.22709;
  unsigned char D.22713;
  unsigned char D.22714;
  struct MonoClass * D.22716;
  struct MonoClass * D.22718;
  struct MonoDomain * D.22719;
  struct MonoVTable * D.22720;
  unsigned char D.22721;
  unsigned char D.22722;
  struct MonoVTable * D.22724;
  struct MonoVTable * D.22725;
  _Bool D.22728;
  long int D.22729;
  long int D.22730;

  mono_loader_lock ();
  {
    int ret;

    D.22683 = &domain->lock.mutex;
    ret = pthread_mutex_lock (D.22683);
    if (ret != 0) goto <D.22684>; else goto <D.22685>;
    <D.22684>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
    <D.22685>:
    D.22686 = ret != 0;
    D.22687 = (long int) D.22686;
    D.22688 = __builtin_expect (D.22687, 0);
    if (D.22688 != 0) goto <D.22689>; else goto <D.22690>;
    <D.22689>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 2617, "ret == 0");
    <D.22690>:
  }
  D.22691 = rp->target_domain_id;
  if (D.22691 != -1) goto <D.22692>; else goto <D.22693>;
  <D.22692>:
  D.22694 = remote_class->xdomain_vtable;
  if (D.22694 == 0B) goto <D.22695>; else goto <D.22696>;
  <D.22695>:
  D.22697 = mono_class_proxy_vtable (domain, remote_class, 1);
  remote_class->xdomain_vtable = D.22697;
  <D.22696>:
  {
    int ret;

    D.22683 = &domain->lock.mutex;
    ret = pthread_mutex_unlock (D.22683);
    if (ret != 0) goto <D.22698>; else goto <D.22699>;
    <D.22698>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.22699>:
    D.22700 = ret != 0;
    D.22701 = (long int) D.22700;
    D.22702 = __builtin_expect (D.22701, 0);
    if (D.22702 != 0) goto <D.22703>; else goto <D.22704>;
    <D.22703>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 2621, "ret == 0");
    <D.22704>:
  }
  mono_loader_unlock ();
  D.22705 = remote_class->xdomain_vtable;
  return D.22705;
  <D.22693>:
  D.22706 = remote_class->default_vtable;
  if (D.22706 == 0B) goto <D.22707>; else goto <D.22708>;
  <D.22707>:
  {
    struct MonoType * type;
    struct MonoClass * klass;

    D.22709 = rp->class_to_proxy;
    type = D.22709->type;
    klass = mono_class_from_mono_type (type);
    D.22713 = BIT_FIELD_REF <*klass, 8, 280>;
    D.22714 = D.22713 & 64;
    if (D.22714 != 0) goto <D.22710>; else goto <D.22715>;
    <D.22715>:
    D.22716 = mono_class_get_com_object_class ();
    if (D.22716 != 0B) goto <D.22717>; else goto <D.22711>;
    <D.22717>:
    D.22718 = mono_class_get_com_object_class ();
    if (D.22718 == klass) goto <D.22710>; else goto <D.22711>;
    <D.22710>:
    D.22719 = mono_domain_get ();
    D.22720 = mono_class_vtable (D.22719, klass);
    D.22721 = BIT_FIELD_REF <*D.22720, 8, 344>;
    D.22722 = D.22721 & 1;
    if (D.22722 == 0) goto <D.22723>; else goto <D.22711>;
    <D.22723>:
    D.22724 = mono_class_proxy_vtable (domain, remote_class, 2);
    remote_class->default_vtable = D.22724;
    goto <D.22712>;
    <D.22711>:
    D.22725 = mono_class_proxy_vtable (domain, remote_class, 0);
    remote_class->default_vtable = D.22725;
    <D.22712>:
  }
  <D.22708>:
  {
    int ret;

    D.22683 = &domain->lock.mutex;
    ret = pthread_mutex_unlock (D.22683);
    if (ret != 0) goto <D.22726>; else goto <D.22727>;
    <D.22726>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.22727>:
    D.22728 = ret != 0;
    D.22729 = (long int) D.22728;
    D.22730 = __builtin_expect (D.22729, 0);
    if (D.22730 != 0) goto <D.22731>; else goto <D.22732>;
    <D.22731>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 2638, "ret == 0");
    <D.22732>:
  }
  mono_loader_unlock ();
  D.22705 = remote_class->default_vtable;
  return D.22705;
}


mono_class_proxy_vtable (struct MonoDomain * domain, struct MonoRemoteClass * remote_class, MonoRemotingTarget target_type)
{
  _Bool D.22734;
  long int D.22735;
  long int D.22736;
  short unsigned int D.22739;
  short unsigned int D.22740;
  short unsigned int D.22741;
  guint8 * D.22744;
  short unsigned int D.22745;
  sizetype D.22746;
  guint8 * D.22747;
  unsigned char D.22748;
  int D.22749;
  int D.22750;
  int D.22751;
  int D.22752;
  int D.22753;
  struct GSList * D.22756;
  int D.22759;
  _Bool D.22760;
  long int D.22761;
  long int D.22762;
  void * * D.22767;
  long unsigned int D.22768;
  long unsigned int D.22769;
  void * * D.22770;
  short unsigned int D.22771;
  short unsigned int D.22774;
  sizetype D.22775;
  guint8 * D.22776;
  unsigned char D.22777;
  int D.22778;
  int D.22779;
  int D.22780;
  int D.22781;
  int D.22782;
  struct GSList * D.22785;
  int D.22788;
  unsigned int i.75;
  unsigned int D.22790;
  long unsigned int D.22791;
  unsigned int D.22792;
  unsigned int D.22793;
  unsigned int extra_interface_vtsize.76;
  unsigned int D.22795;
  short unsigned int D.22796;
  int D.22797;
  unsigned int j.77;
  unsigned int D.22801;
  void * (*<T2788>) (struct MonoVTable *, struct MonoDomain *, struct MonoIMTCheckItem * *, int, void *) imt_thunk_builder.78;
  long unsigned int D.22805;
  long unsigned int D.22806;
  long unsigned int D.22807;
  long unsigned int D.22808;
  int D.22809;
  long unsigned int D.22810;
  long unsigned int D.22811;
  unsigned int D.22812;
  unsigned int D.22813;
  int D.22815;
  long unsigned int D.22816;
  long unsigned int D.22817;
  long unsigned int D.22818;
  unsigned int D.22819;
  unsigned int D.22820;
  long unsigned int D.22821;
  int D.22822;
  long unsigned int D.22823;
  long unsigned int D.22824;
  unsigned int D.22825;
  sizetype D.22829;
  sizetype D.22830;
  sizetype D.22831;
  long unsigned int D.22832;
  long unsigned int D.22833;
  struct MonoClass * D.22834;
  void * D.22835;
  struct MonoMethod * * D.22836;
  struct MonoMethod * * D.22837;
  void * (*<T1deb>) (struct MonoDomain *, struct MonoMethod *, MonoRemotingTarget) arch_create_remoting_trampoline.79;
  void * D.22841;
  unsigned int D.22843;
  unsigned int D.22844;
  short int D.22847;
  int D.22848;
  void * D.22849;
  void * D.22852;
  short unsigned int D.22853;
  int D.22854;
  unsigned int bsize.80;
  struct MonoClass * * D.22858;
  struct MonoClass * * D.22859;
  struct MonoClass * D.22860;
  short unsigned int D.22861;
  guint16 * D.22862;
  long unsigned int D.22863;
  guint16 * D.22864;
  short unsigned int D.22865;
  int D.22866;
  int D.22867;
  long unsigned int D.22868;
  long unsigned int D.22869;
  void * * D.22870;
  void * * D.22871;
  short unsigned int D.22872;
  int D.22873;
  int D.22874;
  sizetype D.22875;
  uint8_t * D.22876;
  unsigned char D.22877;
  signed char D.22878;
  int D.22879;
  int D.22880;
  signed char D.22881;
  signed char D.22882;
  unsigned char D.22883;
  short unsigned int D.22888;
  int D.22889;
  int D.22890;
  long unsigned int D.22891;
  long unsigned int D.22892;
  void * * D.22893;
  void * * D.22894;
  short unsigned int D.22895;
  sizetype D.22896;
  uint8_t * D.22897;
  unsigned char D.22898;
  signed char D.22899;
  int D.22900;
  int D.22901;
  signed char D.22902;
  signed char D.22903;
  unsigned char D.22904;
  int j.81;
  int D.22906;
  void * D.22907;
  int D.22908;
  struct MonoVTable * D.22915;
  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.22734 = vt == 0B;
      D.22735 = (long int) D.22734;
      D.22736 = __builtin_expect (D.22735, 0);
      if (D.22736 != 0) goto <D.22737>; else goto <D.22738>;
      <D.22737>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 2215, "vt");
      <D.22738>:
      D.22739 = vt->max_interface_id;
      max_interface_id = (int) D.22739;
      j = 0;
      goto <D.19590>;
      <D.19589>:
      {
        struct MonoClass * iclass;
        struct GPtrArray * ifaces;
        int method_count;

        iclass = remote_class->interfaces[j];
        D.22740 = iclass->interface_id;
        D.22741 = class->max_interface_id;
        if (D.22740 <= D.22741) goto <D.22742>; else goto <D.22743>;
        <D.22742>:
        D.22744 = class->interface_bitmap;
        D.22740 = iclass->interface_id;
        D.22745 = D.22740 >> 3;
        D.22746 = (sizetype) D.22745;
        D.22747 = D.22744 + D.22746;
        D.22748 = *D.22747;
        D.22749 = (int) D.22748;
        D.22740 = iclass->interface_id;
        D.22750 = (int) D.22740;
        D.22751 = D.22750 & 7;
        D.22752 = D.22749 >> D.22751;
        D.22753 = D.22752 & 1;
        if (D.22753 != 0) goto <D.22754>; else goto <D.22755>;
        <D.22754>:
        // predicted unlikely by continue predictor.
        goto <D.19583>;
        <D.22755>:
        <D.22743>:
        D.22756 = monoeg_g_slist_find (extra_interfaces, iclass);
        if (D.22756 != 0B) goto <D.22757>; else goto <D.22758>;
        <D.22757>:
        // predicted unlikely by continue predictor.
        goto <D.19583>;
        <D.22758>:
        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.22759 = mono_error_ok (&error);
        D.22760 = D.22759 == 0;
        D.22761 = (long int) D.22760;
        D.22762 = __builtin_expect (D.22761, 0);
        if (D.22762 != 0) goto <D.22763>; else goto <D.22764>;
        <D.22763>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 2235, "mono_error_ok (&error)");
        <D.22764>:
        if (ifaces != 0B) goto <D.22765>; else goto <D.22766>;
        <D.22765>:
        i = 0;
        goto <D.19587>;
        <D.19586>:
        {
          struct MonoClass * ic;

          D.22767 = ifaces->pdata;
          D.22768 = (long unsigned int) i;
          D.22769 = D.22768 * 8;
          D.22770 = D.22767 + D.22769;
          ic = *D.22770;
          D.22771 = ic->interface_id;
          D.22741 = class->max_interface_id;
          if (D.22771 <= D.22741) goto <D.22772>; else goto <D.22773>;
          <D.22772>:
          D.22744 = class->interface_bitmap;
          D.22771 = ic->interface_id;
          D.22774 = D.22771 >> 3;
          D.22775 = (sizetype) D.22774;
          D.22776 = D.22744 + D.22775;
          D.22777 = *D.22776;
          D.22778 = (int) D.22777;
          D.22771 = ic->interface_id;
          D.22779 = (int) D.22771;
          D.22780 = D.22779 & 7;
          D.22781 = D.22778 >> D.22780;
          D.22782 = D.22781 & 1;
          if (D.22782 != 0) goto <D.22783>; else goto <D.22784>;
          <D.22783>:
          // predicted unlikely by continue predictor.
          goto <D.19585>;
          <D.22784>:
          <D.22773>:
          D.22785 = monoeg_g_slist_find (extra_interfaces, ic);
          if (D.22785 != 0B) goto <D.22786>; else goto <D.22787>;
          <D.22786>:
          // predicted unlikely by continue predictor.
          goto <D.19585>;
          <D.22787>:
          extra_interfaces = monoeg_g_slist_prepend (extra_interfaces, ic);
          D.22788 = mono_class_num_methods (ic);
          method_count = D.22788 + method_count;
        }
        <D.19585>:
        i = i + 1;
        <D.19587>:
        i.75 = (unsigned int) i;
        D.22790 = ifaces->len;
        if (i.75 < D.22790) goto <D.19586>; else goto <D.19588>;
        <D.19588>:
        monoeg_g_ptr_array_free (ifaces, 1);
        <D.22766>:
        D.22791 = (long unsigned int) method_count;
        D.22792 = (unsigned int) D.22791;
        D.22793 = D.22792 * 8;
        extra_interface_vtsize.76 = (unsigned int) extra_interface_vtsize;
        D.22795 = D.22793 + extra_interface_vtsize.76;
        extra_interface_vtsize = (int) D.22795;
        D.22796 = iclass->max_interface_id;
        D.22797 = (int) D.22796;
        if (D.22797 > max_interface_id) goto <D.22798>; else goto <D.22799>;
        <D.22798>:
        D.22796 = iclass->max_interface_id;
        max_interface_id = (int) D.22796;
        <D.22799>:
      }
      <D.19583>:
      j = j + 1;
      <D.19590>:
      j.77 = (unsigned int) j;
      D.22801 = remote_class->interface_count;
      if (j.77 < D.22801) goto <D.19589>; else goto <D.19591>;
      <D.19591>:
      imt_thunk_builder.78 = imt_thunk_builder;
      if (imt_thunk_builder.78 != 0B) goto <D.22803>; else goto <D.22804>;
      <D.22803>:
      D.22805 = mono_stats.imt_number_of_tables;
      D.22806 = D.22805 + 1;
      mono_stats.imt_number_of_tables = D.22806;
      D.22807 = mono_stats.imt_tables_size;
      D.22808 = D.22807 + 152;
      mono_stats.imt_tables_size = D.22808;
      D.22809 = class->vtable_size;
      D.22810 = (long unsigned int) D.22809;
      D.22811 = D.22810 + 26;
      D.22812 = (unsigned int) D.22811;
      D.22813 = D.22812 * 8;
      vtsize = (int) D.22813;
      goto <D.22814>;
      <D.22804>:
      D.22815 = max_interface_id + 1;
      D.22816 = (long unsigned int) D.22815;
      D.22809 = class->vtable_size;
      D.22810 = (long unsigned int) D.22809;
      D.22817 = D.22816 + D.22810;
      D.22818 = D.22817 + 7;
      D.22819 = (unsigned int) D.22818;
      D.22820 = D.22819 * 8;
      vtsize = (int) D.22820;
      <D.22814>:
      D.22821 = mono_stats.class_vtable_size;
      D.22822 = vtsize + extra_interface_vtsize;
      D.22823 = (long unsigned int) D.22822;
      D.22824 = D.22821 + D.22823;
      mono_stats.class_vtable_size = D.22824;
      D.22822 = vtsize + extra_interface_vtsize;
      D.22825 = (unsigned int) D.22822;
      interface_offsets = mono_domain_alloc0 (domain, D.22825);
      imt_thunk_builder.78 = imt_thunk_builder;
      if (imt_thunk_builder.78 != 0B) goto <D.22826>; else goto <D.22827>;
      <D.22826>:
      pvt = interface_offsets + 152;
      goto <D.22828>;
      <D.22827>:
      D.22829 = (sizetype) max_interface_id;
      D.22830 = D.22829 + 1;
      D.22831 = D.22830 * 8;
      pvt = interface_offsets + D.22831;
      <D.22828>:
      D.22809 = class->vtable_size;
      D.22810 = (long unsigned int) D.22809;
      D.22832 = D.22810 + 7;
      D.22833 = D.22832 * 8;
      memcpy (pvt, vt, D.22833);
      D.22834 = mono_defaults.transparent_proxy_class;
      pvt->klass = D.22834;
      D.22834 = mono_defaults.transparent_proxy_class;
      D.22835 = D.22834->gc_descr;
      pvt->gc_descr = D.22835;
      mono_class_setup_vtable (class);
      i = 0;
      goto <D.19594>;
      <D.19593>:
      {
        struct MonoMethod * cm;

        D.22836 = class->vtable;
        D.22768 = (long unsigned int) i;
        D.22769 = D.22768 * 8;
        D.22837 = D.22836 + D.22769;
        cm = *D.22837;
        if (cm != 0B) goto <D.22838>; else goto <D.22839>;
        <D.22838>:
        arch_create_remoting_trampoline.79 = arch_create_remoting_trampoline;
        D.22841 = arch_create_remoting_trampoline.79 (domain, cm, target_type);
        pvt->vtable[i] = D.22841;
        goto <D.22842>;
        <D.22839>:
        pvt->vtable[i] = 0B;
        <D.22842>:
      }
      i = i + 1;
      <D.19594>:
      D.22809 = class->vtable_size;
      if (D.22809 > i) goto <D.19593>; else goto <D.19595>;
      <D.19595>:
      D.22843 = class->flags;
      D.22844 = D.22843 & 128;
      if (D.22844 != 0) goto <D.22845>; else goto <D.22846>;
      <D.22845>:
      k = class;
      goto <D.19602>;
      <D.19601>:
      {
        struct MonoMethod * m;
        void * iter;

        try
          {
            iter = 0B;
            goto <D.19599>;
            <D.19598>:
            D.22847 = m->slot;
            D.22848 = (int) D.22847;
            D.22849 = pvt->vtable[D.22848];
            if (D.22849 == 0B) goto <D.22850>; else goto <D.22851>;
            <D.22850>:
            D.22847 = m->slot;
            D.22848 = (int) D.22847;
            arch_create_remoting_trampoline.79 = arch_create_remoting_trampoline;
            D.22852 = arch_create_remoting_trampoline.79 (domain, m, target_type);
            pvt->vtable[D.22848] = D.22852;
            <D.22851>:
            <D.19599>:
            m = mono_class_get_methods (k, &iter);
            if (m != 0B) goto <D.19598>; else goto <D.19600>;
            <D.19600>:
          }
        finally
          {
            iter = {CLOBBER};
          }
      }
      k = k->parent;
      <D.19602>:
      if (k != 0B) goto <D.19601>; else goto <D.19603>;
      <D.19603>:
      <D.22846>:
      D.22853 = (short unsigned int) max_interface_id;
      pvt->max_interface_id = D.22853;
      D.22854 = max_interface_id / 8;
      bsize = D.22854 + 1;
      bsize.80 = (unsigned int) bsize;
      bitmap = mono_domain_alloc0 (domain, bsize.80);
      imt_thunk_builder.78 = imt_thunk_builder;
      if (imt_thunk_builder.78 == 0B) goto <D.22856>; else goto <D.22857>;
      <D.22856>:
      i = 0;
      goto <D.19607>;
      <D.19606>:
      {
        int interface_id;
        int slot;

        D.22858 = class->interfaces_packed;
        D.22768 = (long unsigned int) i;
        D.22769 = D.22768 * 8;
        D.22859 = D.22858 + D.22769;
        D.22860 = *D.22859;
        D.22861 = D.22860->interface_id;
        interface_id = (int) D.22861;
        D.22862 = class->interface_offsets_packed;
        D.22768 = (long unsigned int) i;
        D.22863 = D.22768 * 2;
        D.22864 = D.22862 + D.22863;
        D.22865 = *D.22864;
        slot = (int) D.22865;
        D.22741 = class->max_interface_id;
        D.22866 = (int) D.22741;
        D.22867 = D.22866 - interface_id;
        D.22868 = (long unsigned int) D.22867;
        D.22869 = D.22868 * 8;
        D.22870 = interface_offsets + D.22869;
        D.22871 = &pvt->vtable[slot];
        *D.22870 = D.22871;
      }
      i = i + 1;
      <D.19607>:
      D.22872 = class->interface_offsets_count;
      D.22873 = (int) D.22872;
      if (D.22873 > i) goto <D.19606>; else goto <D.19608>;
      <D.19608>:
      <D.22857>:
      i = 0;
      goto <D.19611>;
      <D.19610>:
      {
        int interface_id;

        D.22858 = class->interfaces_packed;
        D.22768 = (long unsigned int) i;
        D.22769 = D.22768 * 8;
        D.22859 = D.22858 + D.22769;
        D.22860 = *D.22859;
        D.22861 = D.22860->interface_id;
        interface_id = (int) D.22861;
        D.22874 = interface_id >> 3;
        D.22875 = (sizetype) D.22874;
        D.22876 = bitmap + D.22875;
        D.22874 = interface_id >> 3;
        D.22875 = (sizetype) D.22874;
        D.22876 = bitmap + D.22875;
        D.22877 = *D.22876;
        D.22878 = (signed char) D.22877;
        D.22879 = interface_id & 7;
        D.22880 = 1 << D.22879;
        D.22881 = (signed char) D.22880;
        D.22882 = D.22878 | D.22881;
        D.22883 = (unsigned char) D.22882;
        *D.22876 = D.22883;
      }
      i = i + 1;
      <D.19611>:
      D.22872 = class->interface_offsets_count;
      D.22873 = (int) D.22872;
      if (D.22873 > i) goto <D.19610>; else goto <D.19612>;
      <D.19612>:
      if (extra_interfaces != 0B) goto <D.22884>; else goto <D.22885>;
      <D.22884>:
      {
        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.19622>;
            <D.19621>:
            interf = list_item->data;
            imt_thunk_builder.78 = imt_thunk_builder;
            if (imt_thunk_builder.78 == 0B) goto <D.22886>; else goto <D.22887>;
            <D.22886>:
            D.22888 = interf->interface_id;
            D.22889 = (int) D.22888;
            D.22890 = max_interface_id - D.22889;
            D.22891 = (long unsigned int) D.22890;
            D.22892 = D.22891 * 8;
            D.22893 = interface_offsets + D.22892;
            D.22894 = &pvt->vtable[slot];
            *D.22893 = D.22894;
            <D.22887>:
            D.22888 = interf->interface_id;
            D.22895 = D.22888 >> 3;
            D.22896 = (sizetype) D.22895;
            D.22897 = bitmap + D.22896;
            D.22888 = interf->interface_id;
            D.22895 = D.22888 >> 3;
            D.22896 = (sizetype) D.22895;
            D.22897 = bitmap + D.22896;
            D.22898 = *D.22897;
            D.22899 = (signed char) D.22898;
            D.22888 = interf->interface_id;
            D.22889 = (int) D.22888;
            D.22900 = D.22889 & 7;
            D.22901 = 1 << D.22900;
            D.22902 = (signed char) D.22901;
            D.22903 = D.22899 | D.22902;
            D.22904 = (unsigned char) D.22903;
            *D.22897 = D.22904;
            iter = 0B;
            j = 0;
            goto <D.19619>;
            <D.19618>:
            j.81 = j;
            j = j.81 + 1;
            D.22906 = j.81 + slot;
            arch_create_remoting_trampoline.79 = arch_create_remoting_trampoline;
            D.22907 = arch_create_remoting_trampoline.79 (domain, cm, target_type);
            pvt->vtable[D.22906] = D.22907;
            <D.19619>:
            cm = mono_class_get_methods (interf, &iter);
            if (cm != 0B) goto <D.19618>; else goto <D.19620>;
            <D.19620>:
            D.22908 = mono_class_num_methods (interf);
            slot = D.22908 + slot;
            list_item = list_item->next;
            <D.19622>:
            if (list_item != 0B) goto <D.19621>; else goto <D.19623>;
            <D.19623>:
            imt_thunk_builder.78 = imt_thunk_builder;
            if (imt_thunk_builder.78 == 0B) goto <D.22909>; else goto <D.22910>;
            <D.22909>:
            monoeg_g_slist_free (extra_interfaces);
            <D.22910>:
          }
        finally
          {
            iter = {CLOBBER};
          }
      }
      <D.22885>:
      imt_thunk_builder.78 = imt_thunk_builder;
      if (imt_thunk_builder.78 != 0B) goto <D.22911>; else goto <D.22912>;
      <D.22911>:
      build_imt (class, pvt, domain, interface_offsets, extra_interfaces);
      if (extra_interfaces != 0B) goto <D.22913>; else goto <D.22914>;
      <D.22913>:
      monoeg_g_slist_free (extra_interfaces);
      <D.22914>:
      <D.22912>:
      pvt->interface_bitmap = bitmap;
      D.22915 = pvt;
      return D.22915;
    }
  finally
    {
      error = {CLOBBER};
    }
}


mono_upgrade_remote_class (struct MonoDomain * domain, struct MonoObject * proxy_object, struct MonoClass * klass)
{
  union mono_mutex_t * D.22918;
  _Bool D.22921;
  long int D.22922;
  long int D.22923;
  unsigned int D.22926;
  unsigned int D.22927;
  struct MonoClass * D.22930;
  unsigned int i.82;
  unsigned int D.22934;
  struct MonoClass * D.22937;
  _Bool D.22938;
  struct MonoRemoteClass * D.22941;
  struct MonoRealProxy * D.22942;
  struct MonoRemoteClass * D.22943;
  void * D.22944;
  _Bool D.22947;
  long int D.22948;
  long int D.22949;
  struct MonoTransparentProxy * tproxy;
  struct MonoRemoteClass * remote_class;
  gboolean redo_vtable;

  mono_loader_lock ();
  {
    int ret;

    D.22918 = &domain->lock.mutex;
    ret = pthread_mutex_lock (D.22918);
    if (ret != 0) goto <D.22919>; else goto <D.22920>;
    <D.22919>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
    <D.22920>:
    D.22921 = ret != 0;
    D.22922 = (long int) D.22921;
    D.22923 = __builtin_expect (D.22922, 0);
    if (D.22923 != 0) goto <D.22924>; else goto <D.22925>;
    <D.22924>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 2661, "ret == 0");
    <D.22925>:
  }
  tproxy = proxy_object;
  remote_class = tproxy->remote_class;
  D.22926 = klass->flags;
  D.22927 = D.22926 & 32;
  if (D.22927 != 0) goto <D.22928>; else goto <D.22929>;
  <D.22928>:
  {
    int i;

    redo_vtable = 1;
    i = 0;
    goto <D.19723>;
    <D.19722>:
    D.22930 = remote_class->interfaces[i];
    if (D.22930 == klass) goto <D.22931>; else goto <D.22932>;
    <D.22931>:
    redo_vtable = 0;
    <D.22932>:
    i = i + 1;
    <D.19723>:
    i.82 = (unsigned int) i;
    D.22934 = remote_class->interface_count;
    if (i.82 < D.22934) goto <D.22935>; else goto <D.19724>;
    <D.22935>:
    if (redo_vtable != 0) goto <D.19722>; else goto <D.19724>;
    <D.19724>:
  }
  goto <D.22936>;
  <D.22929>:
  D.22937 = remote_class->proxy_class;
  D.22938 = D.22937 != klass;
  redo_vtable = (gboolean) D.22938;
  <D.22936>:
  if (redo_vtable != 0) goto <D.22939>; else goto <D.22940>;
  <D.22939>:
  D.22941 = clone_remote_class (domain, remote_class, klass);
  tproxy->remote_class = D.22941;
  D.22942 = tproxy->rp;
  D.22943 = tproxy->remote_class;
  D.22944 = mono_remote_class_vtable (domain, D.22943, D.22942);
  proxy_object->vtable = D.22944;
  <D.22940>:
  {
    int ret;

    D.22918 = &domain->lock.mutex;
    ret = pthread_mutex_unlock (D.22918);
    if (ret != 0) goto <D.22945>; else goto <D.22946>;
    <D.22945>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.22946>:
    D.22947 = ret != 0;
    D.22948 = (long int) D.22947;
    D.22949 = __builtin_expect (D.22948, 0);
    if (D.22949 != 0) goto <D.22950>; else goto <D.22951>;
    <D.22950>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 2682, "ret == 0");
    <D.22951>:
  }
  mono_loader_unlock ();
}


clone_remote_class (struct MonoDomain * domain, struct MonoRemoteClass * remote_class, struct MonoClass * extra_class)
{
  struct GHashTable * D.22952;
  struct MonoRemoteClass * D.22955;
  unsigned int D.22956;
  unsigned int D.22957;
  unsigned int D.22960;
  unsigned int D.22961;
  long unsigned int D.22962;
  long unsigned int D.22963;
  unsigned int D.22964;
  unsigned int D.22965;
  struct MonoClass * D.22966;
  struct MonoClass * D.22967;
  int j.83;
  unsigned int i.84;
  long unsigned int D.22977;
  long unsigned int D.22978;
  unsigned int D.22979;
  unsigned int D.22980;
  unsigned int D.22981;
  long unsigned int D.22984;
  long unsigned int D.22985;
  struct MonoClass *[0:] * D.22986;
  struct MonoClass *[0:] * D.22987;
  char * D.22988;
  struct MonoRemoteClass * rc;
  void * * key;
  void * * mp_key;

  key = create_remote_class_key (remote_class, extra_class);
  D.22952 = domain->proxy_vtable_hash;
  rc = monoeg_g_hash_table_lookup (D.22952, key);
  if (rc != 0B) goto <D.22953>; else goto <D.22954>;
  <D.22953>:
  monoeg_g_free (key);
  D.22955 = rc;
  return D.22955;
  <D.22954>:
  mp_key = copy_remote_class_key (domain, key);
  monoeg_g_free (key);
  key = mp_key;
  D.22956 = extra_class->flags;
  D.22957 = D.22956 & 32;
  if (D.22957 != 0) goto <D.22958>; else goto <D.22959>;
  <D.22958>:
  {
    int i;
    int j;

    D.22960 = remote_class->interface_count;
    D.22961 = D.22960 + 1;
    D.22962 = (long unsigned int) D.22961;
    D.22963 = D.22962 + 5;
    D.22964 = (unsigned int) D.22963;
    D.22965 = D.22964 * 8;
    rc = mono_domain_alloc (domain, D.22965);
    D.22966 = remote_class->proxy_class;
    rc->proxy_class = D.22966;
    D.22960 = remote_class->interface_count;
    D.22961 = D.22960 + 1;
    rc->interface_count = D.22961;
    i = 0;
    j = 0;
    goto <D.19700>;
    <D.19699>:
    D.22967 = remote_class->interfaces[i];
    if (D.22967 > extra_class) goto <D.22968>; else goto <D.22969>;
    <D.22968>:
    if (i == j) goto <D.22970>; else goto <D.22971>;
    <D.22970>:
    j.83 = j;
    j = j.83 + 1;
    rc->interfaces[j.83] = extra_class;
    <D.22971>:
    <D.22969>:
    D.22967 = remote_class->interfaces[i];
    rc->interfaces[j] = D.22967;
    i = i + 1;
    j = j + 1;
    <D.19700>:
    i.84 = (unsigned int) i;
    D.22960 = remote_class->interface_count;
    if (i.84 < D.22960) goto <D.19699>; else goto <D.19701>;
    <D.19701>:
    if (i == j) goto <D.22974>; else goto <D.22975>;
    <D.22974>:
    rc->interfaces[j] = extra_class;
    <D.22975>:
  }
  goto <D.22976>;
  <D.22959>:
  D.22960 = remote_class->interface_count;
  D.22977 = (long unsigned int) D.22960;
  D.22978 = D.22977 + 5;
  D.22979 = (unsigned int) D.22978;
  D.22980 = D.22979 * 8;
  rc = mono_domain_alloc (domain, D.22980);
  rc->proxy_class = extra_class;
  D.22960 = remote_class->interface_count;
  rc->interface_count = D.22960;
  D.22981 = rc->interface_count;
  if (D.22981 != 0) goto <D.22982>; else goto <D.22983>;
  <D.22982>:
  D.22981 = rc->interface_count;
  D.22984 = (long unsigned int) D.22981;
  D.22985 = D.22984 * 8;
  D.22986 = &remote_class->interfaces;
  D.22987 = &rc->interfaces;
  memcpy (D.22987, D.22986, D.22985);
  <D.22983>:
  <D.22976>:
  rc->default_vtable = 0B;
  rc->xdomain_vtable = 0B;
  D.22988 = remote_class->proxy_class_name;
  rc->proxy_class_name = D.22988;
  D.22952 = domain->proxy_vtable_hash;
  monoeg_g_hash_table_insert_replace (D.22952, key, rc, 0);
  D.22955 = rc;
  return D.22955;
}


mono_object_get_virtual_method (struct MonoObject * obj, struct MonoMethod * method)
{
  struct MonoVTable * D.22990;
  struct MonoClass * D.22991;
  struct MonoRemoteClass * D.22994;
  short unsigned int D.22997;
  unsigned int D.22998;
  unsigned int D.22999;
  struct MonoMethod * D.23002;
  short int D.23003;
  unsigned char D.23006;
  unsigned char D.23007;
  struct MonoMethod * D.23010;
  short int D.23011;
  _Bool D.23012;
  long int D.23013;
  long int D.23014;
  struct MonoClass * D.23022;
  unsigned int D.23023;
  unsigned int D.23024;
  _Bool D.23029;
  long int D.23030;
  long int D.23031;
  int D.23034;
  int D.23035;
  long unsigned int D.23036;
  long unsigned int D.23037;
  struct MonoMethod * * D.23038;
  long unsigned int D.23040;
  long unsigned int D.23041;
  struct MonoMethod * * D.23042;
  struct MonoMethodSignature * D.23048;
  short unsigned int D.23049;
  struct MonoMethodSignature * D.23050;
  short unsigned int D.23051;
  struct MonoClass * D.23058;
  unsigned char D.23060;
  unsigned char D.23061;
  struct MonoGenericContext * D.23065;
  _Bool D.23066;
  long int D.23067;
  long int D.23068;
  struct MonoClass * klass;
  struct MonoMethod * * vtable;
  gboolean is_proxy;
  struct MonoMethod * res;

  is_proxy = 0;
  res = 0B;
  D.22990 = obj->vtable;
  klass = D.22990->klass;
  D.22991 = mono_defaults.transparent_proxy_class;
  if (D.22991 == klass) goto <D.22992>; else goto <D.22993>;
  <D.22992>:
  D.22994 = MEM[(struct MonoTransparentProxy *)obj].remote_class;
  klass = D.22994->proxy_class;
  is_proxy = 1;
  <D.22993>:
  if (is_proxy == 0) goto <D.22995>; else goto <D.22996>;
  <D.22995>:
  D.22997 = method->flags;
  D.22998 = (unsigned int) D.22997;
  D.22999 = D.22998 & 96;
  if (D.22999 != 64) goto <D.23000>; else goto <D.23001>;
  <D.23000>:
  D.23002 = method;
  return D.23002;
  <D.23001>:
  <D.22996>:
  mono_class_setup_vtable (klass);
  vtable = klass->vtable;
  D.23003 = method->slot;
  if (D.23003 == -1) goto <D.23004>; else goto <D.23005>;
  <D.23004>:
  D.23006 = BIT_FIELD_REF <*method, 8, 264>;
  D.23007 = D.23006 & 16;
  if (D.23007 != 0) goto <D.23008>; else goto <D.23009>;
  <D.23008>:
  D.23010 = MEM[(struct MonoMethodInflated *)method].declaring;
  D.23011 = D.23010->slot;
  D.23012 = D.23011 == -1;
  D.23013 = (long int) D.23012;
  D.23014 = __builtin_expect (D.23013, 0);
  if (D.23014 != 0) goto <D.23015>; else goto <D.23016>;
  <D.23015>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 2721, "((MonoMethodInflated*)method)->declaring->slot != -1");
  <D.23016>:
  D.23010 = MEM[(struct MonoMethodInflated *)method].declaring;
  D.23011 = D.23010->slot;
  method->slot = D.23011;
  goto <D.23017>;
  <D.23009>:
  if (is_proxy == 0) goto <D.23018>; else goto <D.23019>;
  <D.23018>:
  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "object.c", 2725);
  <D.23019>:
  <D.23017>:
  <D.23005>:
  D.23003 = method->slot;
  if (D.23003 != -1) goto <D.23020>; else goto <D.23021>;
  <D.23020>:
  D.23022 = method->klass;
  D.23023 = D.23022->flags;
  D.23024 = D.23023 & 32;
  if (D.23024 != 0) goto <D.23025>; else goto <D.23026>;
  <D.23025>:
  if (is_proxy == 0) goto <D.23027>; else goto <D.23028>;
  <D.23027>:
  {
    gboolean variance_used;
    int iface_offset;

    try
      {
        variance_used = 0;
        D.23022 = method->klass;
        iface_offset = mono_class_interface_offset_with_variance (klass, D.23022, &variance_used);
        D.23029 = iface_offset <= 0;
        D.23030 = (long int) D.23029;
        D.23031 = __builtin_expect (D.23030, 0);
        if (D.23031 != 0) goto <D.23032>; else goto <D.23033>;
        <D.23032>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 2735, "iface_offset > 0");
        <D.23033>:
        D.23003 = method->slot;
        D.23034 = (int) D.23003;
        D.23035 = D.23034 + iface_offset;
        D.23036 = (long unsigned int) D.23035;
        D.23037 = D.23036 * 8;
        D.23038 = vtable + D.23037;
        res = *D.23038;
      }
    finally
      {
        variance_used = {CLOBBER};
      }
  }
  <D.23028>:
  goto <D.23039>;
  <D.23026>:
  D.23003 = method->slot;
  D.23040 = (long unsigned int) D.23003;
  D.23041 = D.23040 * 8;
  D.23042 = vtable + D.23041;
  res = *D.23042;
  <D.23039>:
  <D.23021>:
  if (is_proxy != 0) goto <D.23043>; else goto <D.23044>;
  <D.23043>:
  if (res == 0B) goto <D.23045>; else goto <D.23047>;
  <D.23047>:
  D.23048 = mono_method_signature (res);
  D.23049 = D.23048->generic_param_count;
  if (D.23049 != 0) goto <D.23045>; else goto <D.23046>;
  <D.23045>:
  res = method;
  <D.23046>:
  D.23050 = mono_method_signature (res);
  D.23051 = D.23050->generic_param_count;
  if (D.23051 != 0) goto <D.23052>; else goto <D.23053>;
  <D.23052>:
  res = mono_marshal_get_remoting_invoke_with_check (res);
  goto <D.23054>;
  <D.23053>:
  D.23058 = mono_class_get_com_object_class ();
  if (D.23058 == klass) goto <D.23055>; else goto <D.23059>;
  <D.23059>:
  D.23060 = BIT_FIELD_REF <*klass, 8, 280>;
  D.23061 = D.23060 & 64;
  if (D.23061 != 0) goto <D.23055>; else goto <D.23056>;
  <D.23055>:
  res = mono_cominterop_get_invoke (res);
  goto <D.23057>;
  <D.23056>:
  res = mono_marshal_get_remoting_invoke (res);
  <D.23057>:
  <D.23054>:
  goto <D.23062>;
  <D.23044>:
  D.23006 = BIT_FIELD_REF <*method, 8, 264>;
  D.23007 = D.23006 & 16;
  if (D.23007 != 0) goto <D.23063>; else goto <D.23064>;
  <D.23063>:
  D.23065 = &MEM[(struct MonoMethodInflated *)method].context;
  res = mono_class_inflate_generic_method (res, D.23065);
  <D.23064>:
  <D.23062>:
  D.23066 = res == 0B;
  D.23067 = (long int) D.23066;
  D.23068 = __builtin_expect (D.23067, 0);
  if (D.23068 != 0) goto <D.23069>; else goto <D.23070>;
  <D.23069>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 2769, "res");
  <D.23070>:
  D.23002 = res;
  return D.23002;
}


mono_runtime_invoke (struct MonoMethod * method, void * obj, void * * params, struct MonoObject * * exc)
{
  int D.23072;
  char * D.23075;
  <unnamed type> D.23076;
  unsigned int D.23077;
  struct MonoObject * (*<T127e>) (struct MonoMethod *, void *, void * *, struct MonoObject * *) default_mono_runtime_invoke.85;
  <unnamed type> D.23081;
  unsigned int D.23082;
  struct MonoObject * D.23085;
  struct MonoObject * result;

  D.23072 = mono_runtime_get_no_exec ();
  if (D.23072 != 0) goto <D.23073>; else goto <D.23074>;
  <D.23073>:
  D.23075 = mono_method_full_name (method, 1);
  monoeg_g_log (0B, 16, "Invoking method \'%s\' when running in no-exec mode.\n", D.23075);
  <D.23074>:
  D.23076 = mono_profiler_get_events ();
  D.23077 = D.23076 & 65536;
  if (D.23077 != 0) goto <D.23078>; else goto <D.23079>;
  <D.23078>:
  mono_profiler_method_start_invoke (method);
  <D.23079>:
  default_mono_runtime_invoke.85 = default_mono_runtime_invoke;
  result = default_mono_runtime_invoke.85 (method, obj, params, exc);
  D.23081 = mono_profiler_get_events ();
  D.23082 = D.23081 & 65536;
  if (D.23082 != 0) goto <D.23083>; else goto <D.23084>;
  <D.23083>:
  mono_profiler_method_end_invoke (method);
  <D.23084>:
  D.23085 = result;
  return D.23085;
}


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

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


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

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


mono_field_set_value (struct MonoObject * obj, struct MonoClassField * field, void * value)
{
  struct MonoType * D.23091;
  short unsigned int D.23092;
  int D.23093;
  int D.23094;
  int D.23097;
  sizetype D.23098;
  void * dest;

  D.23091 = field->type;
  D.23092 = D.23091->attrs;
  D.23093 = (int) D.23092;
  D.23094 = D.23093 & 16;
  if (D.23094 != 0) goto <D.23095>; else goto <D.23096>;
  <D.23095>:
  monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "object.c", 3003, "!(field->type->attrs & FIELD_ATTRIBUTE_STATIC)");
  return;
  <D.23096>:
  D.23097 = field->offset;
  D.23098 = (sizetype) D.23097;
  dest = obj + D.23098;
  D.23091 = field->type;
  set_value (D.23091, dest, value, 0);
}


set_value (struct MonoType * type, void * dest, void * value, int deref_pointer)
{
  unsigned char D.23100;
  unsigned char D.23101;
  unsigned char D.23104;
  guint8 iftmp.86;
  guint16 iftmp.87;
  int iftmp.88;
  gint64 iftmp.89;
  float iftmp.90;
  double iftmp.91;
  struct MonoObject * iftmp.92;
  void * iftmp.93;
  struct MonoClass * D.23139;
  unsigned char D.23140;
  unsigned char D.23141;
  struct MonoType * D.23143;
  unsigned char D.23144;
  long unsigned int D.23147;
  struct MonoGenericClass * D.23149;
  struct MonoClass * D.23150;
  unsigned char D.23151;
  int D.23152;
  int t;
  void handle_enum = <<< error >>>;

  D.23100 = BIT_FIELD_REF <*type, 8, 88>;
  D.23101 = D.23100 & 64;
  if (D.23101 != 0) goto <D.23102>; else goto <D.23103>;
  <D.23102>:
  {
    void * * p;

    p = dest;
    *p = value;
    return;
  }
  <D.23103>:
  D.23104 = type->type;
  t = (int) D.23104;
  handle_enum:
  switch (t) <default: <D.19795>, case 2: <D.19763>, case 3: <D.19769>, case 4: <D.19764>, case 5: <D.19765>, case 6: <D.19767>, case 7: <D.19768>, case 8: <D.19771>, case 9: <D.19772>, case 10: <D.19776>, case 11: <D.19777>, case 12: <D.19779>, case 13: <D.19781>, case 14: <D.19783>, case 15: <D.19789>, case 17: <D.19791>, case 18: <D.19785>, case 20: <D.19787>, case 21: <D.19794>, case 24: <D.19774>, case 25: <D.19775>, case 27: <D.19788>, case 28: <D.19786>, case 29: <D.19784>>
  <D.19763>:
  <D.19764>:
  <D.19765>:
  {
    guint8 * p;

    p = dest;
    if (value != 0B) goto <D.23106>; else goto <D.23107>;
    <D.23106>:
    iftmp.86 = MEM[(guint8 *)value];
    goto <D.23108>;
    <D.23107>:
    iftmp.86 = 0;
    <D.23108>:
    *p = iftmp.86;
    return;
  }
  <D.19767>:
  <D.19768>:
  <D.19769>:
  {
    guint16 * p;

    p = dest;
    if (value != 0B) goto <D.23110>; else goto <D.23111>;
    <D.23110>:
    iftmp.87 = MEM[(guint16 *)value];
    goto <D.23112>;
    <D.23111>:
    iftmp.87 = 0;
    <D.23112>:
    *p = iftmp.87;
    return;
  }
  <D.19771>:
  <D.19772>:
  {
    gint32 * p;

    p = dest;
    if (value != 0B) goto <D.23114>; else goto <D.23115>;
    <D.23114>:
    iftmp.88 = MEM[(gint32 *)value];
    goto <D.23116>;
    <D.23115>:
    iftmp.88 = 0;
    <D.23116>:
    *p = iftmp.88;
    return;
  }
  <D.19774>:
  <D.19775>:
  <D.19776>:
  <D.19777>:
  {
    gint64 * p;

    p = dest;
    if (value != 0B) goto <D.23118>; else goto <D.23119>;
    <D.23118>:
    iftmp.89 = MEM[(gint64 *)value];
    goto <D.23120>;
    <D.23119>:
    iftmp.89 = 0;
    <D.23120>:
    *p = iftmp.89;
    return;
  }
  <D.19779>:
  {
    float * p;

    p = dest;
    if (value != 0B) goto <D.23122>; else goto <D.23123>;
    <D.23122>:
    iftmp.90 = MEM[(float *)value];
    goto <D.23124>;
    <D.23123>:
    iftmp.90 = 0.0;
    <D.23124>:
    *p = iftmp.90;
    return;
  }
  <D.19781>:
  {
    double * p;

    p = dest;
    if (value != 0B) goto <D.23126>; else goto <D.23127>;
    <D.23126>:
    iftmp.91 = MEM[(double *)value];
    goto <D.23128>;
    <D.23127>:
    iftmp.91 = 0.0;
    <D.23128>:
    *p = iftmp.91;
    return;
  }
  <D.19783>:
  <D.19784>:
  <D.19785>:
  <D.19786>:
  <D.19787>:
  if (deref_pointer != 0) goto <D.23130>; else goto <D.23131>;
  <D.23130>:
  iftmp.92 = MEM[(void * *)value];
  goto <D.23132>;
  <D.23131>:
  iftmp.92 = value;
  <D.23132>:
  mono_gc_wbarrier_generic_store (dest, iftmp.92);
  return;
  <D.19788>:
  <D.19789>:
  {
    void * * p;

    p = dest;
    if (deref_pointer != 0) goto <D.23134>; else goto <D.23135>;
    <D.23134>:
    iftmp.93 = MEM[(void * *)value];
    goto <D.23136>;
    <D.23135>:
    iftmp.93 = value;
    <D.23136>:
    *p = iftmp.93;
    return;
  }
  <D.19791>:
  D.23104 = type->type;
  if (D.23104 == 17) goto <D.23138>; else goto <D.23137>;
  <D.23138>:
  D.23139 = type->data.klass;
  D.23140 = BIT_FIELD_REF <*D.23139, 8, 256>;
  D.23141 = D.23140 & 16;
  if (D.23141 != 0) goto <D.23142>; else goto <D.23137>;
  <D.23142>:
  D.23139 = type->data.klass;
  D.23143 = mono_class_enum_basetype (D.23139);
  D.23144 = D.23143->type;
  t = (int) D.23144;
  goto handle_enum;
  <D.23137>:
  {
    struct MonoClass * class;
    int size;

    class = mono_class_from_mono_type (type);
    size = mono_class_value_size (class, 0B);
    if (value == 0B) goto <D.23145>; else goto <D.23146>;
    <D.23145>:
    D.23147 = (long unsigned int) size;
    mono_gc_bzero_atomic (dest, D.23147);
    goto <D.23148>;
    <D.23146>:
    mono_gc_wbarrier_value_copy (dest, value, 1, class);
    <D.23148>:
  }
  return;
  <D.19794>:
  D.23149 = type->data.generic_class;
  D.23150 = D.23149->container_class;
  D.23151 = D.23150->byval_arg.type;
  t = (int) D.23151;
  goto handle_enum;
  <D.19795>:
  D.23104 = type->type;
  D.23152 = (int) D.23104;
  monoeg_g_log (0B, 4, "got type %x", D.23152);
  <D.19796>:
  goto <D.19796>;
}


mono_field_static_set_value (struct MonoVTable * vt, struct MonoClassField * field, void * value)
{
  struct MonoType * D.23154;
  short unsigned int D.23155;
  int D.23156;
  int D.23157;
  int D.23160;
  int D.23163;
  struct MonoDomain * D.23166;
  union mono_mutex_t * D.23167;
  _Bool D.23170;
  long int D.23171;
  long int D.23172;
  struct GHashTable * D.23175;
  _Bool D.23178;
  long int D.23179;
  long int D.23180;
  long int addr.94;
  unsigned int D.23184;
  void * D.23186;
  sizetype D.23187;
  void * dest;

  D.23154 = field->type;
  D.23155 = D.23154->attrs;
  D.23156 = (int) D.23155;
  D.23157 = D.23156 & 16;
  if (D.23157 == 0) goto <D.23158>; else goto <D.23159>;
  <D.23158>:
  monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "object.c", 3024, "field->type->attrs & FIELD_ATTRIBUTE_STATIC");
  return;
  <D.23159>:
  D.23154 = field->type;
  D.23155 = D.23154->attrs;
  D.23156 = (int) D.23155;
  D.23160 = D.23156 & 64;
  if (D.23160 != 0) goto <D.23161>; else goto <D.23162>;
  <D.23161>:
  monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "object.c", 3026, "!(field->type->attrs & FIELD_ATTRIBUTE_LITERAL)");
  return;
  <D.23162>:
  D.23163 = field->offset;
  if (D.23163 == -1) goto <D.23164>; else goto <D.23165>;
  <D.23164>:
  {
    void * addr;

    {
      int ret;

      D.23166 = vt->domain;
      D.23167 = &D.23166->lock.mutex;
      ret = pthread_mutex_lock (D.23167);
      if (ret != 0) goto <D.23168>; else goto <D.23169>;
      <D.23168>:
      monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
      <D.23169>:
      D.23170 = ret != 0;
      D.23171 = (long int) D.23170;
      D.23172 = __builtin_expect (D.23171, 0);
      if (D.23172 != 0) goto <D.23173>; else goto <D.23174>;
      <D.23173>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 3032, "ret == 0");
      <D.23174>:
    }
    D.23166 = vt->domain;
    D.23175 = D.23166->special_static_fields;
    addr = monoeg_g_hash_table_lookup (D.23175, field);
    {
      int ret;

      D.23166 = vt->domain;
      D.23167 = &D.23166->lock.mutex;
      ret = pthread_mutex_unlock (D.23167);
      if (ret != 0) goto <D.23176>; else goto <D.23177>;
      <D.23176>:
      monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
      <D.23177>:
      D.23178 = ret != 0;
      D.23179 = (long int) D.23178;
      D.23180 = __builtin_expect (D.23179, 0);
      if (D.23180 != 0) goto <D.23181>; else goto <D.23182>;
      <D.23181>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 3034, "ret == 0");
      <D.23182>:
    }
    addr.94 = (long int) addr;
    D.23184 = (unsigned int) addr.94;
    dest = mono_get_special_static_data (D.23184);
  }
  goto <D.23185>;
  <D.23165>:
  D.23186 = mono_vtable_get_static_field_data (vt);
  D.23163 = field->offset;
  D.23187 = (sizetype) D.23163;
  dest = D.23186 + D.23187;
  <D.23185>:
  D.23154 = field->type;
  set_value (D.23154, dest, value, 0);
}


mono_vtable_get_static_field_data (struct MonoVTable * vt)
{
  unsigned char D.23189;
  unsigned char D.23190;
  void * D.23193;
  struct MonoClass * D.23194;
  int D.23195;

  D.23189 = BIT_FIELD_REF <*vt, 8, 344>;
  D.23190 = D.23189 & 8;
  if (D.23190 == 0) goto <D.23191>; else goto <D.23192>;
  <D.23191>:
  D.23193 = 0B;
  return D.23193;
  <D.23192>:
  D.23194 = vt->klass;
  D.23195 = D.23194->vtable_size;
  D.23193 = vt->vtable[D.23195];
  return D.23193;
}


mono_field_get_value (struct MonoObject * obj, struct MonoClassField * field, void * value)
{
  _Bool D.23197;
  long int D.23198;
  long int D.23199;
  struct MonoType * D.23202;
  short unsigned int D.23203;
  int D.23204;
  int D.23205;
  int D.23208;
  sizetype D.23209;
  void * src;

  D.23197 = obj == 0B;
  D.23198 = (long int) D.23197;
  D.23199 = __builtin_expect (D.23198, 0);
  if (D.23199 != 0) goto <D.23200>; else goto <D.23201>;
  <D.23200>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 3103, "obj");
  <D.23201>:
  D.23202 = field->type;
  D.23203 = D.23202->attrs;
  D.23204 = (int) D.23203;
  D.23205 = D.23204 & 16;
  if (D.23205 != 0) goto <D.23206>; else goto <D.23207>;
  <D.23206>:
  monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "object.c", 3105, "!(field->type->attrs & FIELD_ATTRIBUTE_STATIC)");
  return;
  <D.23207>:
  D.23208 = field->offset;
  D.23209 = (sizetype) D.23208;
  src = obj + D.23209;
  D.23202 = field->type;
  set_value (D.23202, value, src, 1);
}


mono_field_get_value_object (struct MonoDomain * domain, struct MonoClassField * field, struct MonoObject * obj)
{
  int D.23211;
  unsigned char D.23214;
  int D.23215;
  <unnamed-unsigned:1> D.23216;
  int D.23217;
  _Bool D.23218;
  struct MonoObject * D.23219;
  short unsigned int D.23220;
  int D.23221;
  int D.23222;
  int D.23225;
  struct MonoClass * D.23230;
  unsigned char D.23231;
  unsigned char D.23232;
  _Bool D.23236;
  long int D.23237;
  long int D.23238;
  struct MonoMethod * m.95;
  struct MonoClass * ptr_klass.98;
  struct MonoClass * tmp_klass.96;
  struct MonoImage * D.23259;
  struct MonoClass * tmp_klass.97;
  _Bool D.23261;
  long int D.23262;
  long int D.23263;
  struct MonoMethod * m.99;
  _Bool D.23267;
  long int D.23268;
  long int D.23269;
  void * * ptr.100;
  void * D.23279;
  struct MonoDomain * D.23280;
  struct MonoReflectionType * D.23281;
  int D.23282;
  guint8 * D.23285;
  struct MonoObject * o.101;
  struct MonoObject * o.102;
  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.23211 = mono_error_ok (&error);
      if (D.23211 == 0) goto <D.23212>; else goto <D.23213>;
      <D.23212>:
      mono_error_raise_exception (&error);
      <D.23213>:
      D.23214 = type->type;
      D.23215 = (int) D.23214;
      switch (D.23215) <default: <D.19868>, case 2: <D.19853>, case 3: <D.19856>, case 4: <D.19852>, case 5: <D.19851>, case 6: <D.19855>, case 7: <D.19854>, case 8: <D.19860>, case 9: <D.19859>, case 10: <D.19863>, case 11: <D.19862>, case 12: <D.19861>, case 13: <D.19864>, case 14: <D.19845>, case 15: <D.19867>, case 17: <D.19865>, case 18: <D.19847>, case 20: <D.19848>, case 21: <D.19866>, case 24: <D.19858>, case 25: <D.19857>, case 28: <D.19846>, case 29: <D.19849>>
      <D.19845>:
      <D.19846>:
      <D.19847>:
      <D.19848>:
      <D.19849>:
      is_ref = 1;
      goto <D.19850>;
      <D.19851>:
      <D.19852>:
      <D.19853>:
      <D.19854>:
      <D.19855>:
      <D.19856>:
      <D.19857>:
      <D.19858>:
      <D.19859>:
      <D.19860>:
      <D.19861>:
      <D.19862>:
      <D.19863>:
      <D.19864>:
      <D.19865>:
      D.23216 = type->byref;
      is_ref = (gboolean) D.23216;
      goto <D.19850>;
      <D.19866>:
      D.23217 = mono_type_generic_inst_is_valuetype (type);
      D.23218 = D.23217 == 0;
      is_ref = (gboolean) D.23218;
      goto <D.19850>;
      <D.19867>:
      is_ptr = 1;
      goto <D.19850>;
      <D.19868>:
      D.23214 = type->type;
      D.23215 = (int) D.23214;
      monoeg_g_log (0B, 4, "type 0x%x not handled in mono_field_get_value_object", D.23215);
      <D.19869>:
      goto <D.19869>;
      D.23219 = 0B;
      return D.23219;
      <D.19850>:
      D.23220 = type->attrs;
      D.23221 = (int) D.23220;
      D.23222 = D.23221 & 64;
      if (D.23222 != 0) goto <D.23223>; else goto <D.23224>;
      <D.23223>:
      is_literal = 1;
      <D.23224>:
      D.23220 = type->attrs;
      D.23221 = (int) D.23220;
      D.23225 = D.23221 & 16;
      if (D.23225 != 0) goto <D.23226>; else goto <D.23227>;
      <D.23226>:
      is_static = 1;
      if (is_literal == 0) goto <D.23228>; else goto <D.23229>;
      <D.23228>:
      D.23230 = field->parent;
      vtable = mono_class_vtable_full (domain, D.23230, 1);
      D.23231 = BIT_FIELD_REF <*vtable, 8, 344>;
      D.23232 = D.23231 & 2;
      if (D.23232 == 0) goto <D.23233>; else goto <D.23234>;
      <D.23233>:
      mono_runtime_class_init (vtable);
      <D.23234>:
      <D.23229>:
      goto <D.23235>;
      <D.23227>:
      D.23236 = obj == 0B;
      D.23237 = (long int) D.23236;
      D.23238 = __builtin_expect (D.23237, 0);
      if (D.23238 != 0) goto <D.23239>; else goto <D.23240>;
      <D.23239>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 3187, "obj");
      <D.23240>:
      <D.23235>:
      if (is_ref != 0) goto <D.23241>; else goto <D.23242>;
      <D.23241>:
      if (is_literal != 0) goto <D.23243>; else goto <D.23244>;
      <D.23243>:
      get_default_field_value (domain, field, &o);
      goto <D.23245>;
      <D.23244>:
      if (is_static != 0) goto <D.23246>; else goto <D.23247>;
      <D.23246>:
      mono_field_static_get_value (vtable, field, &o);
      goto <D.23248>;
      <D.23247>:
      mono_field_get_value (obj, field, &o);
      <D.23248>:
      <D.23245>:
      D.23219 = o;
      return D.23219;
      <D.23242>:
      if (is_ptr != 0) goto <D.23249>; else goto <D.23250>;
      <D.23249>:
      {
        static struct MonoMethod * m;
        void * args[2];
        void * * ptr;
        void * v;

        try
          {
            m.95 = m;
            if (m.95 == 0B) goto <D.23252>; else goto <D.23253>;
            <D.23252>:
            {
              struct MonoClass * ptr_klass;

              {
                static struct MonoClass * tmp_klass;

                {
                  tmp_klass.96 = tmp_klass;
                  if (tmp_klass.96 == 0B) goto <D.23255>; else goto <D.23256>;
                  <D.23255>:
                  if (0 != 0) goto <D.23257>; else goto <D.23258>;
                  <D.23257>:
                  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 3208, "mono_defaults.corlib == mono_defaults.corlib");
                  <D.23258>:
                  D.23259 = mono_defaults.corlib;
                  tmp_klass.97 = mono_class_from_name (D.23259, "System.Reflection", "Pointer");
                  tmp_klass = tmp_klass.97;
                  tmp_klass.96 = tmp_klass;
                  D.23261 = tmp_klass.96 == 0B;
                  D.23262 = (long int) D.23261;
                  D.23263 = __builtin_expect (D.23262, 0);
                  if (D.23263 != 0) goto <D.23264>; else goto <D.23265>;
                  <D.23264>:
                  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 3208, "tmp_klass");
                  <D.23265>:
                  <D.23256>:
                }
                ptr_klass.98 = tmp_klass;
              }
              ptr_klass = ptr_klass.98;
              m.99 = mono_class_get_method_from_name_flags (ptr_klass, "Box", 2, 16);
              m = m.99;
              m.95 = m;
              D.23267 = m.95 == 0B;
              D.23268 = (long int) D.23267;
              D.23269 = __builtin_expect (D.23268, 0);
              if (D.23269 != 0) goto <D.23270>; else goto <D.23271>;
              <D.23270>:
              monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 3210, "m");
              <D.23271>:
            }
            <D.23253>:
            v = &ptr;
            if (is_literal != 0) goto <D.23272>; else goto <D.23273>;
            <D.23272>:
            get_default_field_value (domain, field, v);
            goto <D.23274>;
            <D.23273>:
            if (is_static != 0) goto <D.23275>; else goto <D.23276>;
            <D.23275>:
            mono_field_static_get_value (vtable, field, v);
            goto <D.23277>;
            <D.23276>:
            mono_field_get_value (obj, field, v);
            <D.23277>:
            <D.23274>:
            ptr.100 = ptr;
            D.23279 = *ptr.100;
            args[0] = D.23279;
            D.23280 = mono_domain_get ();
            D.23281 = mono_type_get_object (D.23280, type);
            args[1] = D.23281;
            m.95 = m;
            D.23219 = mono_runtime_invoke (m.95, 0B, &args, 0B);
            return D.23219;
          }
        finally
          {
            args = {CLOBBER};
            ptr = {CLOBBER};
          }
      }
      <D.23250>:
      klass = mono_class_from_mono_type (type);
      D.23282 = mono_class_is_nullable (klass);
      if (D.23282 != 0) goto <D.23283>; else goto <D.23284>;
      <D.23283>:
      D.23285 = mono_field_get_addr (obj, vtable, field);
      D.23219 = mono_nullable_box (D.23285, klass);
      return D.23219;
      <D.23284>:
      o.101 = mono_object_new (domain, klass);
      o = o.101;
      o.102 = o;
      v = o.102 + 16;
      if (is_literal != 0) goto <D.23288>; else goto <D.23289>;
      <D.23288>:
      get_default_field_value (domain, field, v);
      goto <D.23290>;
      <D.23289>:
      if (is_static != 0) goto <D.23291>; else goto <D.23292>;
      <D.23291>:
      mono_field_static_get_value (vtable, field, v);
      goto <D.23293>;
      <D.23292>:
      mono_field_get_value (obj, field, v);
      <D.23293>:
      <D.23290>:
      D.23219 = o;
      return D.23219;
    }
  finally
    {
      o = {CLOBBER};
      error = {CLOBBER};
    }
}


mono_field_get_addr (struct MonoObject * obj, struct MonoVTable * vt, struct MonoClassField * field)
{
  struct MonoType * D.23297;
  short unsigned int D.23298;
  int D.23299;
  int D.23300;
  int D.23303;
  struct MonoDomain * D.23306;
  union mono_mutex_t * D.23307;
  _Bool D.23310;
  long int D.23311;
  long int D.23312;
  struct GHashTable * D.23315;
  _Bool D.23318;
  long int D.23319;
  long int D.23320;
  long int addr.103;
  unsigned int D.23324;
  void * D.23326;
  sizetype D.23327;
  guint8 * D.23329;
  guint8 * src;

  D.23297 = field->type;
  D.23298 = D.23297->attrs;
  D.23299 = (int) D.23298;
  D.23300 = D.23299 & 16;
  if (D.23300 != 0) goto <D.23301>; else goto <D.23302>;
  <D.23301>:
  D.23303 = field->offset;
  if (D.23303 == -1) goto <D.23304>; else goto <D.23305>;
  <D.23304>:
  {
    void * addr;

    {
      int ret;

      D.23306 = vt->domain;
      D.23307 = &D.23306->lock.mutex;
      ret = pthread_mutex_lock (D.23307);
      if (ret != 0) goto <D.23308>; else goto <D.23309>;
      <D.23308>:
      monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
      <D.23309>:
      D.23310 = ret != 0;
      D.23311 = (long int) D.23310;
      D.23312 = __builtin_expect (D.23311, 0);
      if (D.23312 != 0) goto <D.23313>; else goto <D.23314>;
      <D.23313>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 3067, "ret == 0");
      <D.23314>:
    }
    D.23306 = vt->domain;
    D.23315 = D.23306->special_static_fields;
    addr = monoeg_g_hash_table_lookup (D.23315, field);
    {
      int ret;

      D.23306 = vt->domain;
      D.23307 = &D.23306->lock.mutex;
      ret = pthread_mutex_unlock (D.23307);
      if (ret != 0) goto <D.23316>; else goto <D.23317>;
      <D.23316>:
      monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
      <D.23317>:
      D.23318 = ret != 0;
      D.23319 = (long int) D.23318;
      D.23320 = __builtin_expect (D.23319, 0);
      if (D.23320 != 0) goto <D.23321>; else goto <D.23322>;
      <D.23321>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 3069, "ret == 0");
      <D.23322>:
    }
    addr.103 = (long int) addr;
    D.23324 = (unsigned int) addr.103;
    src = mono_get_special_static_data (D.23324);
  }
  goto <D.23325>;
  <D.23305>:
  D.23326 = mono_vtable_get_static_field_data (vt);
  D.23303 = field->offset;
  D.23327 = (sizetype) D.23303;
  src = D.23326 + D.23327;
  <D.23325>:
  goto <D.23328>;
  <D.23302>:
  D.23303 = field->offset;
  D.23327 = (sizetype) D.23303;
  src = obj + D.23327;
  <D.23328>:
  D.23329 = src;
  return D.23329;
}


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

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


mono_get_constant_value_from_blob (struct MonoDomain * domain, MonoTypeEnum type, const char * blob, void * value)
{
  const char * p.105;
  char D.23333;
  unsigned char D.23334;
  short unsigned int D.23335;
  unsigned int D.23336;
  long unsigned int D.23337;
  float D.23338;
  double D.23339;
  struct MonoString * D.23340;
  int D.23341;
  int retval;
  const char * p;

  try
    {
      retval = 0;
      p = blob;
      p.105 = p;
      mono_metadata_decode_blob_size (p.105, &p);
      switch (type) <default: <D.19902>, case 2: <D.19885>, case 3: <D.19889>, case 4: <D.19887>, case 5: <D.19886>, case 6: <D.19891>, case 7: <D.19890>, case 8: <D.19893>, case 9: <D.19892>, case 10: <D.19895>, case 11: <D.19894>, case 12: <D.19896>, case 13: <D.19898>, case 14: <D.19900>, case 18: <D.19901>>
      <D.19885>:
      <D.19886>:
      <D.19887>:
      p.105 = p;
      D.23333 = *p.105;
      D.23334 = (unsigned char) D.23333;
      MEM[(guint8 *)value] = D.23334;
      goto <D.19888>;
      <D.19889>:
      <D.19890>:
      <D.19891>:
      p.105 = p;
      D.23335 = MEM[(const guint16 *)p.105];
      MEM[(guint16 *)value] = D.23335;
      goto <D.19888>;
      <D.19892>:
      <D.19893>:
      p.105 = p;
      D.23336 = MEM[(const guint32 *)p.105];
      MEM[(guint32 *)value] = D.23336;
      goto <D.19888>;
      <D.19894>:
      <D.19895>:
      p.105 = p;
      D.23337 = MEM[(const guint64 *)p.105];
      MEM[(guint64 *)value] = D.23337;
      goto <D.19888>;
      <D.19896>:
      {
        union mono_rfloat mf;

        try
          {
            p.105 = p;
            D.23336 = MEM[(const guint32 *)p.105];
            mf.ival = D.23336;
            D.23338 = mf.fval;
            MEM[(float *)value] = D.23338;
          }
        finally
          {
            mf = {CLOBBER};
          }
      }
      goto <D.19888>;
      <D.19898>:
      {
        union mono_rdouble mf;

        try
          {
            p.105 = p;
            D.23337 = MEM[(const guint64 *)p.105];
            mf.ival = D.23337;
            D.23339 = mf.fval;
            MEM[(double *)value] = D.23339;
          }
        finally
          {
            mf = {CLOBBER};
          }
      }
      goto <D.19888>;
      <D.19900>:
      D.23340 = mono_ldstr_metadata_sig (domain, blob);
      MEM[(void * *)value] = D.23340;
      goto <D.19888>;
      <D.19901>:
      MEM[(void * *)value] = 0B;
      goto <D.19888>;
      <D.19902>:
      retval = -1;
      monoeg_g_log (0B, 16, "type 0x%02x should not be in constant table", type);
      <D.19888>:
      D.23341 = retval;
      return D.23341;
    }
  finally
    {
      p = {CLOBBER};
    }
}


mono_ldstr_metadata_sig (struct MonoDomain * domain, const char * sig)
{
  const char * str.106;
  unsigned int D.23345;
  int D.23346;
  _Bool D.23349;
  long int D.23350;
  long int D.23351;
  struct MonoGHashTable * D.23354;
  _Bool D.23359;
  long int D.23360;
  long int D.23361;
  struct MonoString * D.23364;
  _Bool D.23369;
  long int D.23370;
  long int D.23371;
  const char * str;
  struct MonoString * o;
  struct MonoString * interned;
  size_t len2;

  try
    {
      str = sig;
      str.106 = str;
      D.23345 = mono_metadata_decode_blob_size (str.106, &str);
      len2 = (size_t) D.23345;
      len2 = len2 >> 1;
      D.23346 = (int) len2;
      str.106 = str;
      o = mono_string_new_utf16 (domain, str.106, D.23346);
      {
        int ret;

        ret = pthread_mutex_lock (&ldstr_section.mutex);
        if (ret != 0) goto <D.23347>; else goto <D.23348>;
        <D.23347>:
        monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
        <D.23348>:
        D.23349 = ret != 0;
        D.23350 = (long int) D.23349;
        D.23351 = __builtin_expect (D.23350, 0);
        if (D.23351 != 0) goto <D.23352>; else goto <D.23353>;
        <D.23352>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 5487, "ret == 0");
        <D.23353>:
      }
      D.23354 = domain->ldstr_table;
      interned = mono_g_hash_table_lookup (D.23354, o);
      if (interned != 0B) goto <D.23355>; else goto <D.23356>;
      <D.23355>:
      {
        int ret;

        ret = pthread_mutex_unlock (&ldstr_section.mutex);
        if (ret != 0) goto <D.23357>; else goto <D.23358>;
        <D.23357>:
        monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
        <D.23358>:
        D.23359 = ret != 0;
        D.23360 = (long int) D.23359;
        D.23361 = __builtin_expect (D.23360, 0);
        if (D.23361 != 0) goto <D.23362>; else goto <D.23363>;
        <D.23362>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 5489, "ret == 0");
        <D.23363>:
      }
      D.23364 = interned;
      return D.23364;
      <D.23356>:
      o = mono_string_get_pinned (o);
      if (o != 0B) goto <D.23365>; else goto <D.23366>;
      <D.23365>:
      D.23354 = domain->ldstr_table;
      mono_g_hash_table_insert (D.23354, o, o);
      <D.23366>:
      {
        int ret;

        ret = pthread_mutex_unlock (&ldstr_section.mutex);
        if (ret != 0) goto <D.23367>; else goto <D.23368>;
        <D.23367>:
        monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
        <D.23368>:
        D.23369 = ret != 0;
        D.23370 = (long int) D.23369;
        D.23371 = __builtin_expect (D.23370, 0);
        if (D.23371 != 0) goto <D.23372>; else goto <D.23373>;
        <D.23372>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 5497, "ret == 0");
        <D.23373>:
      }
      D.23364 = o;
      return D.23364;
    }
  finally
    {
      str = {CLOBBER};
    }
}


mono_string_get_pinned (struct MonoString * str)
{
  int D.23376;
  int D.23377;
  int D.23378;
  unsigned int D.23379;
  unsigned int D.23380;
  long unsigned int D.23381;
  struct MonoVTable * D.23382;
  int D.23385;
  int D.23386;
  long unsigned int D.23387;
  mono_unichar2 * D.23388;
  mono_unichar2 * D.23389;
  int D.23390;
  struct MonoString * D.23391;
  int size;
  struct MonoString * news;

  D.23376 = mono_string_length (str);
  D.23377 = D.23376 + 1;
  D.23378 = D.23377 * 2;
  D.23379 = (unsigned int) D.23378;
  D.23380 = D.23379 + 24;
  size = (int) D.23380;
  D.23381 = (long unsigned int) size;
  D.23382 = MEM[(struct MonoObject *)str].vtable;
  news = mono_gc_alloc_pinned_obj (D.23382, D.23381);
  if (news != 0B) goto <D.23383>; else goto <D.23384>;
  <D.23383>:
  D.23385 = mono_string_length (str);
  D.23386 = D.23385 * 2;
  D.23387 = (long unsigned int) D.23386;
  D.23388 = mono_string_chars (str);
  D.23389 = mono_string_chars (news);
  memcpy (D.23389, D.23388, D.23387);
  D.23390 = mono_string_length (str);
  news->length = D.23390;
  <D.23384>:
  D.23391 = news;
  return D.23391;
}


mono_field_static_get_value_for_thread (struct MonoInternalThread * thread, struct MonoVTable * vt, struct MonoClassField * field, void * value)
{
  struct MonoType * D.23393;
  short unsigned int D.23394;
  int D.23395;
  int D.23396;
  int D.23399;
  struct MonoDomain * D.23402;
  int D.23403;
  struct GHashTable * D.23406;
  long int addr.107;
  unsigned int D.23408;
  void * D.23410;
  sizetype D.23411;
  void * src;

  D.23393 = field->type;
  D.23394 = D.23393->attrs;
  D.23395 = (int) D.23394;
  D.23396 = D.23395 & 16;
  if (D.23396 == 0) goto <D.23397>; else goto <D.23398>;
  <D.23397>:
  monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "object.c", 3309, "field->type->attrs & FIELD_ATTRIBUTE_STATIC");
  return;
  <D.23398>:
  D.23393 = field->type;
  D.23394 = D.23393->attrs;
  D.23395 = (int) D.23394;
  D.23399 = D.23395 & 64;
  if (D.23399 != 0) goto <D.23400>; else goto <D.23401>;
  <D.23400>:
  D.23402 = vt->domain;
  get_default_field_value (D.23402, field, value);
  return;
  <D.23401>:
  D.23403 = field->offset;
  if (D.23403 == -1) goto <D.23404>; else goto <D.23405>;
  <D.23404>:
  {
    void * addr;

    D.23402 = vt->domain;
    D.23406 = D.23402->special_static_fields;
    addr = monoeg_g_hash_table_lookup (D.23406, field);
    addr.107 = (long int) addr;
    D.23408 = (unsigned int) addr.107;
    src = mono_get_special_static_data_for_thread (thread, D.23408);
  }
  goto <D.23409>;
  <D.23405>:
  D.23410 = mono_vtable_get_static_field_data (vt);
  D.23403 = field->offset;
  D.23411 = (sizetype) D.23403;
  src = D.23410 + D.23411;
  <D.23409>:
  D.23393 = field->type;
  set_value (D.23393, value, src, 1);
}


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

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


mono_property_set_value (struct MonoProperty * prop, void * obj, void * * params, struct MonoObject * * exc)
{
  struct MonoObject * (*<T127e>) (struct MonoMethod *, void *, void * *, struct MonoObject * *) default_mono_runtime_invoke.108;
  struct MonoMethod * D.23416;

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


mono_property_get_value (struct MonoProperty * prop, void * obj, void * * params, struct MonoObject * * exc)
{
  struct MonoObject * D.23417;
  struct MonoObject * (*<T127e>) (struct MonoMethod *, void *, void * *, struct MonoObject * *) default_mono_runtime_invoke.109;
  struct MonoMethod * D.23419;

  default_mono_runtime_invoke.109 = default_mono_runtime_invoke;
  D.23419 = prop->get;
  D.23417 = default_mono_runtime_invoke.109 (D.23419, obj, params, exc);
  return D.23417;
}


mono_nullable_init (guint8 * buf, struct MonoObject * value, struct MonoClass * klass)
{
  unsigned char D.23421;
  unsigned char D.23422;
  _Bool D.23423;
  long int D.23424;
  long int D.23425;
  struct MonoClassField * D.23428;
  struct MonoType * D.23429;
  struct MonoClass * D.23430;
  _Bool D.23431;
  long int D.23432;
  long int D.23433;
  struct MonoClassField * D.23436;
  struct MonoType * D.23437;
  struct MonoClass * D.23438;
  struct MonoClass * D.23439;
  _Bool D.23440;
  long int D.23441;
  long int D.23442;
  int D.23445;
  sizetype D.23446;
  sizetype D.23447;
  guint8 * D.23448;
  _Bool D.23449;
  unsigned char D.23450;
  unsigned char D.23453;
  unsigned char D.23454;
  void * D.23457;
  int D.23458;
  sizetype D.23459;
  sizetype D.23460;
  guint8 * D.23461;
  int D.23463;
  long unsigned int D.23464;
  void * D.23465;
  int D.23467;
  long unsigned int D.23468;
  struct MonoClass * param_class;

  param_class = klass->cast_class;
  mono_class_setup_fields_locking (klass);
  D.23421 = BIT_FIELD_REF <*klass, 8, 288>;
  D.23422 = D.23421 & 32;
  D.23423 = D.23422 == 0;
  D.23424 = (long int) D.23423;
  D.23425 = __builtin_expect (D.23424, 0);
  if (D.23425 != 0) goto <D.23426>; else goto <D.23427>;
  <D.23426>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 3412, "klass->fields_inited");
  <D.23427>:
  D.23428 = klass->fields;
  D.23429 = D.23428->type;
  D.23430 = mono_class_from_mono_type (D.23429);
  D.23431 = D.23430 != param_class;
  D.23432 = (long int) D.23431;
  D.23433 = __builtin_expect (D.23432, 0);
  if (D.23433 != 0) goto <D.23434>; else goto <D.23435>;
  <D.23434>:
  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.23435>:
  D.23428 = klass->fields;
  D.23436 = D.23428 + 32;
  D.23437 = D.23436->type;
  D.23438 = mono_class_from_mono_type (D.23437);
  D.23439 = mono_defaults.boolean_class;
  D.23440 = D.23438 != D.23439;
  D.23441 = (long int) D.23440;
  D.23442 = __builtin_expect (D.23441, 0);
  if (D.23442 != 0) goto <D.23443>; else goto <D.23444>;
  <D.23443>:
  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.23444>:
  D.23428 = klass->fields;
  D.23436 = D.23428 + 32;
  D.23445 = D.23436->offset;
  D.23446 = (sizetype) D.23445;
  D.23447 = D.23446 + 18446744073709551600;
  D.23448 = buf + D.23447;
  D.23449 = value != 0B;
  D.23450 = (unsigned char) D.23449;
  *D.23448 = D.23450;
  if (value != 0B) goto <D.23451>; else goto <D.23452>;
  <D.23451>:
  D.23453 = BIT_FIELD_REF <*param_class, 8, 280>;
  D.23454 = D.23453 & 8;
  if (D.23454 != 0) goto <D.23455>; else goto <D.23456>;
  <D.23455>:
  D.23457 = mono_object_unbox (value);
  D.23428 = klass->fields;
  D.23458 = D.23428->offset;
  D.23459 = (sizetype) D.23458;
  D.23460 = D.23459 + 18446744073709551600;
  D.23461 = buf + D.23460;
  mono_gc_wbarrier_value_copy (D.23461, D.23457, 1, param_class);
  goto <D.23462>;
  <D.23456>:
  D.23463 = mono_class_value_size (param_class, 0B);
  D.23464 = (long unsigned int) D.23463;
  D.23465 = mono_object_unbox (value);
  D.23428 = klass->fields;
  D.23458 = D.23428->offset;
  D.23459 = (sizetype) D.23458;
  D.23460 = D.23459 + 18446744073709551600;
  D.23461 = buf + D.23460;
  mono_gc_memmove_atomic (D.23461, D.23465, D.23464);
  <D.23462>:
  goto <D.23466>;
  <D.23452>:
  D.23467 = mono_class_value_size (param_class, 0B);
  D.23468 = (long unsigned int) D.23467;
  D.23428 = klass->fields;
  D.23458 = D.23428->offset;
  D.23459 = (sizetype) D.23458;
  D.23460 = D.23459 + 18446744073709551600;
  D.23461 = buf + D.23460;
  mono_gc_bzero_atomic (D.23461, D.23468);
  <D.23466>:
}


mono_nullable_box (guint8 * buf, struct MonoClass * klass)
{
  unsigned char D.23469;
  unsigned char D.23470;
  _Bool D.23471;
  long int D.23472;
  long int D.23473;
  struct MonoClassField * D.23476;
  struct MonoType * D.23477;
  struct MonoClass * D.23478;
  _Bool D.23479;
  long int D.23480;
  long int D.23481;
  struct MonoClassField * D.23484;
  struct MonoType * D.23485;
  struct MonoClass * D.23486;
  struct MonoClass * D.23487;
  _Bool D.23488;
  long int D.23489;
  long int D.23490;
  int D.23493;
  sizetype D.23494;
  sizetype D.23495;
  guint8 * D.23496;
  unsigned char D.23497;
  struct MonoDomain * D.23500;
  unsigned char D.23501;
  unsigned char D.23502;
  int D.23505;
  sizetype D.23506;
  sizetype D.23507;
  guint8 * D.23508;
  void * D.23509;
  int D.23511;
  long unsigned int D.23512;
  void * D.23513;
  struct MonoObject * D.23514;
  struct MonoClass * param_class;

  param_class = klass->cast_class;
  mono_class_setup_fields_locking (klass);
  D.23469 = BIT_FIELD_REF <*klass, 8, 288>;
  D.23470 = D.23469 & 32;
  D.23471 = D.23470 == 0;
  D.23472 = (long int) D.23471;
  D.23473 = __builtin_expect (D.23472, 0);
  if (D.23473 != 0) goto <D.23474>; else goto <D.23475>;
  <D.23474>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 3442, "klass->fields_inited");
  <D.23475>:
  D.23476 = klass->fields;
  D.23477 = D.23476->type;
  D.23478 = mono_class_from_mono_type (D.23477);
  D.23479 = D.23478 != param_class;
  D.23480 = (long int) D.23479;
  D.23481 = __builtin_expect (D.23480, 0);
  if (D.23481 != 0) goto <D.23482>; else goto <D.23483>;
  <D.23482>:
  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.23483>:
  D.23476 = klass->fields;
  D.23484 = D.23476 + 32;
  D.23485 = D.23484->type;
  D.23486 = mono_class_from_mono_type (D.23485);
  D.23487 = mono_defaults.boolean_class;
  D.23488 = D.23486 != D.23487;
  D.23489 = (long int) D.23488;
  D.23490 = __builtin_expect (D.23489, 0);
  if (D.23490 != 0) goto <D.23491>; else goto <D.23492>;
  <D.23491>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 3445, "mono_class_from_mono_type (klass->fields [1].type) == mono_defaults.boolean_class");
  <D.23492>:
  D.23476 = klass->fields;
  D.23484 = D.23476 + 32;
  D.23493 = D.23484->offset;
  D.23494 = (sizetype) D.23493;
  D.23495 = D.23494 + 18446744073709551600;
  D.23496 = buf + D.23495;
  D.23497 = *D.23496;
  if (D.23497 != 0) goto <D.23498>; else goto <D.23499>;
  <D.23498>:
  {
    struct MonoObject * o;

    D.23500 = mono_domain_get ();
    o = mono_object_new (D.23500, param_class);
    D.23501 = BIT_FIELD_REF <*param_class, 8, 280>;
    D.23502 = D.23501 & 8;
    if (D.23502 != 0) goto <D.23503>; else goto <D.23504>;
    <D.23503>:
    D.23476 = klass->fields;
    D.23505 = D.23476->offset;
    D.23506 = (sizetype) D.23505;
    D.23507 = D.23506 + 18446744073709551600;
    D.23508 = buf + D.23507;
    D.23509 = mono_object_unbox (o);
    mono_gc_wbarrier_value_copy (D.23509, D.23508, 1, param_class);
    goto <D.23510>;
    <D.23504>:
    D.23511 = mono_class_value_size (param_class, 0B);
    D.23512 = (long unsigned int) D.23511;
    D.23476 = klass->fields;
    D.23505 = D.23476->offset;
    D.23506 = (sizetype) D.23505;
    D.23507 = D.23506 + 18446744073709551600;
    D.23508 = buf + D.23507;
    D.23513 = mono_object_unbox (o);
    mono_gc_memmove_atomic (D.23513, D.23508, D.23512);
    <D.23510>:
    D.23514 = o;
    return D.23514;
  }
  <D.23499>:
  D.23514 = 0B;
  return D.23514;
}


mono_get_delegate_invoke (struct MonoClass * klass)
{
  unsigned char D.23516;
  struct MonoMethod * D.23519;
  struct MonoMethod * im;

  mono_class_setup_methods (klass);
  D.23516 = klass->exception_type;
  if (D.23516 != 0) goto <D.23517>; else goto <D.23518>;
  <D.23517>:
  D.23519 = 0B;
  return D.23519;
  <D.23518>:
  im = mono_class_get_method_from_name (klass, "Invoke", -1);
  D.23519 = im;
  return D.23519;
}


mono_get_delegate_begin_invoke (struct MonoClass * klass)
{
  unsigned char D.23521;
  struct MonoMethod * D.23524;
  struct MonoMethod * im;

  mono_class_setup_methods (klass);
  D.23521 = klass->exception_type;
  if (D.23521 != 0) goto <D.23522>; else goto <D.23523>;
  <D.23522>:
  D.23524 = 0B;
  return D.23524;
  <D.23523>:
  im = mono_class_get_method_from_name (klass, "BeginInvoke", -1);
  D.23524 = im;
  return D.23524;
}


mono_get_delegate_end_invoke (struct MonoClass * klass)
{
  unsigned char D.23526;
  struct MonoMethod * D.23529;
  struct MonoMethod * im;

  mono_class_setup_methods (klass);
  D.23526 = klass->exception_type;
  if (D.23526 != 0) goto <D.23527>; else goto <D.23528>;
  <D.23527>:
  D.23529 = 0B;
  return D.23529;
  <D.23528>:
  im = mono_class_get_method_from_name (klass, "EndInvoke", -1);
  D.23529 = im;
  return D.23529;
}


mono_runtime_delegate_invoke (struct MonoObject * delegate, void * * params, struct MonoObject * * exc)
{
  struct MonoVTable * D.23531;
  char * D.23534;
  struct MonoObject * D.23535;
  struct MonoMethod * im;
  struct MonoClass * klass;

  D.23531 = delegate->vtable;
  klass = D.23531->klass;
  im = mono_get_delegate_invoke (klass);
  if (im == 0B) goto <D.23532>; else goto <D.23533>;
  <D.23532>:
  D.23534 = mono_type_get_full_name (klass);
  monoeg_g_log (0B, 4, "Could not lookup delegate invoke method for delegate %s", D.23534);
  <D.19966>:
  goto <D.19966>;
  <D.23533>:
  D.23535 = mono_runtime_invoke (im, delegate, params, exc);
  return D.23535;
}


mono_runtime_get_main_args ()
{
  char * * main_args.110;
  struct MonoArray * D.23540;
  int num_main_args.111;
  long unsigned int D.23542;
  struct MonoClass * D.23543;
  long unsigned int D.23544;
  long unsigned int D.23545;
  long unsigned int D.23546;
  char * * D.23547;
  char * D.23548;
  struct MonoString * D.23549;
  struct MonoArray * res;
  int i;
  struct MonoDomain * domain;

  domain = mono_domain_get ();
  main_args.110 = main_args;
  if (main_args.110 == 0B) goto <D.23538>; else goto <D.23539>;
  <D.23538>:
  D.23540 = 0B;
  return D.23540;
  <D.23539>:
  num_main_args.111 = num_main_args;
  D.23542 = (long unsigned int) num_main_args.111;
  D.23543 = mono_defaults.string_class;
  res = mono_array_new (domain, D.23543, D.23542);
  i = 0;
  goto <D.19977>;
  <D.19976>:
  {
    void * * __p;

    D.23544 = (long unsigned int) i;
    __p = mono_array_addr_with_size (res, 8, D.23544);
    main_args.110 = main_args;
    D.23545 = (long unsigned int) i;
    D.23546 = D.23545 * 8;
    D.23547 = main_args.110 + D.23546;
    D.23548 = *D.23547;
    D.23549 = mono_string_new (domain, D.23548);
    mono_gc_wbarrier_set_arrayref (res, __p, D.23549);
  }
  i = i + 1;
  <D.19977>:
  num_main_args.111 = num_main_args;
  if (i < num_main_args.111) goto <D.19976>; else goto <D.19978>;
  <D.19978>:
  D.23540 = res;
  return D.23540;
}


mono_runtime_run_main (struct MonoMethod * method, int argc, char * * argv, struct MonoObject * * exc)
{
  _Bool D.23551;
  long int D.23552;
  long int D.23553;
  struct MonoThread * D.23556;
  long unsigned int D.23557;
  long unsigned int D.23558;
  void * main_args.112;
  char * D.23560;
  int D.23561;
  struct MonoClass * D.23564;
  struct MonoImage * D.23565;
  struct MonoAssembly * D.23566;
  char * D.23567;
  char * * main_args.113;
  long unsigned int D.23574;
  long unsigned int D.23575;
  char * * D.23576;
  char * D.23577;
  char * * D.23580;
  short unsigned int D.23583;
  long unsigned int D.23586;
  struct MonoClass * D.23587;
  long unsigned int D.23588;
  int D.23590;
  int i;
  struct MonoArray * args;
  struct MonoDomain * domain;
  gchar * utf8_fullpath;
  struct MonoMethodSignature * sig;

  args = 0B;
  domain = mono_domain_get ();
  D.23551 = method == 0B;
  D.23552 = (long int) D.23551;
  D.23553 = __builtin_expect (D.23552, 0);
  if (D.23553 != 0) goto <D.23554>; else goto <D.23555>;
  <D.23554>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 3601, "method != NULL");
  <D.23555>:
  D.23556 = mono_thread_current ();
  mono_thread_set_main (D.23556);
  D.23557 = (long unsigned int) argc;
  D.23558 = D.23557 * 8;
  main_args.112 = monoeg_malloc0 (D.23558);
  main_args = main_args.112;
  num_main_args = argc;
  D.23560 = *argv;
  D.23561 = monoeg_g_path_is_absolute (D.23560);
  if (D.23561 == 0) goto <D.23562>; else goto <D.23563>;
  <D.23562>:
  {
    gchar * basename;
    gchar * fullpath;

    D.23560 = *argv;
    basename = monoeg_g_path_get_basename (D.23560);
    D.23564 = method->klass;
    D.23565 = D.23564->image;
    D.23566 = D.23565->assembly;
    D.23567 = D.23566->basedir;
    fullpath = monoeg_g_build_path ("/", D.23567, basename, 0B);
    utf8_fullpath = mono_utf8_from_external (fullpath);
    if (utf8_fullpath == 0B) goto <D.23568>; else goto <D.23569>;
    <D.23568>:
    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.23569>:
    monoeg_g_free (fullpath);
    monoeg_g_free (basename);
  }
  goto <D.23570>;
  <D.23563>:
  D.23560 = *argv;
  utf8_fullpath = mono_utf8_from_external (D.23560);
  if (utf8_fullpath == 0B) goto <D.23571>; else goto <D.23572>;
  <D.23571>:
  D.23560 = *argv;
  monoeg_g_print ("\nCannot determine the text encoding for the assembly location: %s\n", D.23560);
  monoeg_g_print ("Please add the correct encoding to MONO_EXTERNAL_ENCODINGS and try again.\n");
  exit (-1);
  <D.23572>:
  <D.23570>:
  main_args.113 = main_args;
  *main_args.113 = utf8_fullpath;
  i = 1;
  goto <D.20001>;
  <D.20000>:
  {
    gchar * utf8_arg;

    D.23574 = (long unsigned int) i;
    D.23575 = D.23574 * 8;
    D.23576 = argv + D.23575;
    D.23577 = *D.23576;
    utf8_arg = mono_utf8_from_external (D.23577);
    if (utf8_arg == 0B) goto <D.23578>; else goto <D.23579>;
    <D.23578>:
    D.23574 = (long unsigned int) i;
    D.23575 = D.23574 * 8;
    D.23576 = argv + D.23575;
    D.23577 = *D.23576;
    monoeg_g_print ("\nCannot determine the text encoding for argument %d (%s).\n", i, D.23577);
    monoeg_g_print ("Please add the correct encoding to MONO_EXTERNAL_ENCODINGS and try again.\n");
    exit (-1);
    <D.23579>:
    main_args.113 = main_args;
    D.23574 = (long unsigned int) i;
    D.23575 = D.23574 * 8;
    D.23580 = main_args.113 + D.23575;
    *D.23580 = utf8_arg;
  }
  i = i + 1;
  <D.20001>:
  if (i < argc) goto <D.20000>; else goto <D.20002>;
  <D.20002>:
  argc = argc + -1;
  argv = argv + 8;
  sig = mono_method_signature (method);
  if (sig == 0B) goto <D.23581>; else goto <D.23582>;
  <D.23581>:
  monoeg_g_print ("Unable to load Main method.\n");
  exit (-1);
  <D.23582>:
  D.23583 = sig->param_count;
  if (D.23583 != 0) goto <D.23584>; else goto <D.23585>;
  <D.23584>:
  D.23586 = (long unsigned int) argc;
  D.23587 = mono_defaults.string_class;
  args = mono_array_new (domain, D.23587, D.23586);
  i = 0;
  goto <D.20007>;
  <D.20006>:
  {
    gchar * str;
    struct MonoString * arg;

    D.23574 = (long unsigned int) i;
    D.23575 = D.23574 * 8;
    D.23576 = argv + D.23575;
    D.23577 = *D.23576;
    str = mono_utf8_from_external (D.23577);
    arg = mono_string_new (domain, str);
    {
      void * * __p;

      D.23588 = (long unsigned int) i;
      __p = mono_array_addr_with_size (args, 8, D.23588);
      mono_gc_wbarrier_set_arrayref (args, __p, arg);
    }
    monoeg_g_free (str);
  }
  i = i + 1;
  <D.20007>:
  if (i < argc) goto <D.20006>; else goto <D.20008>;
  <D.20008>:
  goto <D.23589>;
  <D.23585>:
  D.23587 = mono_defaults.string_class;
  args = mono_array_new (domain, D.23587, 0);
  <D.23589>:
  D.23564 = method->klass;
  D.23565 = D.23564->image;
  D.23566 = D.23565->assembly;
  mono_assembly_set_main (D.23566);
  D.23590 = mono_runtime_exec_main (method, args, exc);
  return D.23590;
}


mono_object_xdomain_representation (struct MonoObject * obj, struct MonoDomain * target_domain, struct MonoObject * * exc)
{
  struct MonoVTable * D.23592;
  struct MonoClass * D.23593;
  unsigned char D.23594;
  unsigned char D.23595;
  struct MonoDomain * D.23599;
  int failure.114;
  struct MonoObject * D.23605;
  struct MonoObject * deserialized;
  gboolean failure;

  try
    {
      deserialized = 0B;
      failure = 0;
      *exc = 0B;
      D.23592 = obj->vtable;
      D.23593 = D.23592->klass;
      D.23594 = BIT_FIELD_REF <*D.23593, 8, 272>;
      D.23595 = D.23594 & 64;
      if (D.23595 != 0) goto <D.23596>; else goto <D.23597>;
      <D.23596>:
      deserialized = make_transparent_proxy (obj, &failure, exc);
      goto <D.23598>;
      <D.23597>:
      {
        struct MonoDomain * domain;
        struct MonoObject * serialized;

        domain = mono_domain_get ();
        D.23592 = obj->vtable;
        D.23599 = D.23592->domain;
        mono_domain_set_internal_with_options (D.23599, 0);
        serialized = serialize_object (obj, &failure, exc);
        mono_domain_set_internal_with_options (target_domain, 0);
        failure.114 = failure;
        if (failure.114 == 0) goto <D.23601>; else goto <D.23602>;
        <D.23601>:
        deserialized = deserialize_object (serialized, &failure, exc);
        <D.23602>:
        if (domain != target_domain) goto <D.23603>; else goto <D.23604>;
        <D.23603>:
        mono_domain_set_internal_with_options (domain, 0);
        <D.23604>:
      }
      <D.23598>:
      D.23605 = deserialized;
      return D.23605;
    }
  finally
    {
      failure = {CLOBBER};
    }
}


make_transparent_proxy (struct MonoObject * obj, gboolean * failure, struct MonoObject * * exc)
{
  struct MonoMethod * get_proxy_method.115;
  struct MonoClass * D.23611;
  struct MonoMethod * get_proxy_method.116;
  struct MonoVTable * D.23613;
  struct MonoClass * D.23614;
  unsigned char D.23615;
  unsigned char D.23616;
  _Bool D.23617;
  long int D.23618;
  long int D.23619;
  struct MonoType * D.23622;
  struct MonoReflectionType * * D.23623;
  struct MonoObject * * D.23624;
  struct MonoObject * D.23625;
  struct MonoObject * D.23628;
  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.115 = get_proxy_method;
  if (get_proxy_method.115 == 0B) goto <D.23609>; else goto <D.23610>;
  <D.23609>:
  D.23611 = mono_defaults.real_proxy_class;
  get_proxy_method.116 = mono_class_get_method_from_name (D.23611, "GetTransparentProxy", 0);
  get_proxy_method = get_proxy_method.116;
  <D.23610>:
  D.23613 = obj->vtable;
  D.23614 = D.23613->klass;
  D.23615 = BIT_FIELD_REF <*D.23614, 8, 272>;
  D.23616 = D.23615 & 64;
  D.23617 = D.23616 == 0;
  D.23618 = (long int) D.23617;
  D.23619 = __builtin_expect (D.23618, 0);
  if (D.23619 != 0) goto <D.23620>; else goto <D.23621>;
  <D.23620>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 3751, "mono_class_is_marshalbyref (obj->vtable->klass)");
  <D.23621>:
  D.23611 = mono_defaults.real_proxy_class;
  real_proxy = mono_object_new (domain, D.23611);
  D.23613 = obj->vtable;
  D.23614 = D.23613->klass;
  D.23622 = &D.23614->byval_arg;
  reflection_type = mono_type_get_object (domain, D.23622);
  D.23623 = &real_proxy->class_to_proxy;
  mono_gc_wbarrier_set_field (real_proxy, D.23623, reflection_type);
  D.23624 = &real_proxy->unwrapped_server;
  mono_gc_wbarrier_set_field (real_proxy, D.23624, obj);
  *exc = 0B;
  get_proxy_method.115 = get_proxy_method;
  transparent_proxy = mono_runtime_invoke (get_proxy_method.115, real_proxy, 0B, exc);
  D.23625 = *exc;
  if (D.23625 != 0B) goto <D.23626>; else goto <D.23627>;
  <D.23626>:
  *failure = 1;
  <D.23627>:
  D.23628 = transparent_proxy;
  return D.23628;
}


serialize_object (struct MonoObject * obj, gboolean * failure, struct MonoObject * * exc)
{
  struct MonoMethod * serialize_method.117;
  struct MonoImage * D.23633;
  struct MonoMethod * serialize_method.118;
  struct MonoObject * D.23637;
  struct MonoVTable * D.23638;
  struct MonoClass * D.23639;
  unsigned char D.23640;
  unsigned char D.23641;
  _Bool D.23642;
  long int D.23643;
  long int D.23644;
  struct MonoObject * D.23647;
  static struct MonoMethod * serialize_method;
  void * params[1];
  struct MonoObject * array;

  try
    {
      serialize_method.117 = serialize_method;
      if (serialize_method.117 == 0B) goto <D.23631>; else goto <D.23632>;
      <D.23631>:
      {
        struct MonoClass * klass;

        D.23633 = mono_defaults.corlib;
        klass = mono_class_from_name (D.23633, "System.Runtime.Remoting", "RemotingServices");
        serialize_method.118 = mono_class_get_method_from_name (klass, "SerializeCallData", -1);
        serialize_method = serialize_method.118;
      }
      <D.23632>:
      serialize_method.117 = serialize_method;
      if (serialize_method.117 == 0B) goto <D.23635>; else goto <D.23636>;
      <D.23635>:
      *failure = 1;
      D.23637 = 0B;
      return D.23637;
      <D.23636>:
      D.23638 = obj->vtable;
      D.23639 = D.23638->klass;
      D.23640 = BIT_FIELD_REF <*D.23639, 8, 272>;
      D.23641 = D.23640 & 64;
      D.23642 = D.23641 != 0;
      D.23643 = (long int) D.23642;
      D.23644 = __builtin_expect (D.23643, 0);
      if (D.23644 != 0) goto <D.23645>; else goto <D.23646>;
      <D.23645>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 3700, "!mono_class_is_marshalbyref (mono_object_class (obj))");
      <D.23646>:
      params[0] = obj;
      *exc = 0B;
      serialize_method.117 = serialize_method;
      array = mono_runtime_invoke (serialize_method.117, 0B, &params, exc);
      D.23647 = *exc;
      if (D.23647 != 0B) goto <D.23648>; else goto <D.23649>;
      <D.23648>:
      *failure = 1;
      <D.23649>:
      D.23637 = array;
      return D.23637;
    }
  finally
    {
      params = {CLOBBER};
    }
}


deserialize_object (struct MonoObject * obj, gboolean * failure, struct MonoObject * * exc)
{
  struct MonoMethod * deserialize_method.119;
  struct MonoImage * D.23655;
  struct MonoMethod * deserialize_method.120;
  struct MonoObject * D.23659;
  struct MonoObject * D.23660;
  static struct MonoMethod * deserialize_method;
  void * params[1];
  struct MonoObject * result;

  try
    {
      deserialize_method.119 = deserialize_method;
      if (deserialize_method.119 == 0B) goto <D.23653>; else goto <D.23654>;
      <D.23653>:
      {
        struct MonoClass * klass;

        D.23655 = mono_defaults.corlib;
        klass = mono_class_from_name (D.23655, "System.Runtime.Remoting", "RemotingServices");
        deserialize_method.120 = mono_class_get_method_from_name (klass, "DeserializeCallData", -1);
        deserialize_method = deserialize_method.120;
      }
      <D.23654>:
      deserialize_method.119 = deserialize_method;
      if (deserialize_method.119 == 0B) goto <D.23657>; else goto <D.23658>;
      <D.23657>:
      *failure = 1;
      D.23659 = 0B;
      return D.23659;
      <D.23658>:
      params[0] = obj;
      *exc = 0B;
      deserialize_method.119 = deserialize_method;
      result = mono_runtime_invoke (deserialize_method.119, 0B, &params, exc);
      D.23660 = *exc;
      if (D.23660 != 0B) goto <D.23661>; else goto <D.23662>;
      <D.23661>:
      *failure = 1;
      <D.23662>:
      D.23659 = result;
      return D.23659;
    }
  finally
    {
      params = {CLOBBER};
    }
}


mono_runtime_unhandled_exception_policy_set (MonoRuntimeUnhandledExceptionPolicy policy)
{
  runtime_unhandled_exception_policy = policy;
}


mono_runtime_unhandled_exception_policy_get ()
{
  MonoRuntimeUnhandledExceptionPolicy D.23665;

  D.23665 = runtime_unhandled_exception_policy;
  return D.23665;
}


mono_unhandled_exception (struct MonoObject * exc)
{
  struct MonoClass * D.23667;
  _Bool D.23668;
  long int D.23669;
  long int D.23670;
  struct MonoVTable * D.23673;
  struct MonoClass * D.23674;
  struct MonoClass * D.23675;
  int iftmp.121;
  struct MonoThread * main_thread.122;
  struct MonoInternalThread * D.23685;
  struct _MonoInternalThread * D.23686;
  <unnamed type> D.23687;
  struct MonoAppDomain * D.23688;
  int D.23689;
  sizetype D.23690;
  struct MonoObject * * D.23691;
  struct MonoAppDomain * D.23694;
  struct MonoObject * * D.23695;
  _Bool D.23697;
  _Bool D.23698;
  _Bool D.23699;
  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.23667 = mono_defaults.appdomain_class;
  field = mono_class_get_field_from_name (D.23667, "UnhandledException");
  D.23668 = field == 0B;
  D.23669 = (long int) D.23668;
  D.23670 = __builtin_expect (D.23669, 0);
  if (D.23670 != 0) goto <D.23671>; else goto <D.23672>;
  <D.23671>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 3940, "field");
  <D.23672>:
  D.23673 = exc->vtable;
  D.23674 = D.23673->klass;
  D.23675 = mono_defaults.threadabortexception_class;
  if (D.23674 != D.23675) goto <D.23676>; else goto <D.23677>;
  <D.23676>:
  {
    gboolean abort_process;

    main_thread.122 = main_thread;
    if (main_thread.122 != 0B) goto <D.23684>; else goto <D.23679>;
    <D.23684>:
    D.23685 = mono_thread_internal_current ();
    main_thread.122 = main_thread;
    D.23686 = main_thread.122->internal_thread;
    if (D.23685 == D.23686) goto <D.23680>; else goto <D.23679>;
    <D.23679>:
    D.23687 = mono_runtime_unhandled_exception_policy_get ();
    if (D.23687 == 1) goto <D.23680>; else goto <D.23681>;
    <D.23680>:
    iftmp.121 = 1;
    goto <D.23682>;
    <D.23681>:
    iftmp.121 = 0;
    <D.23682>:
    abort_process = iftmp.121;
    D.23688 = root_domain->domain;
    D.23689 = field->offset;
    D.23690 = (sizetype) D.23689;
    D.23691 = D.23688 + D.23690;
    root_appdomain_delegate = *D.23691;
    if (current_domain != root_domain) goto <D.23692>; else goto <D.23693>;
    <D.23692>:
    D.23694 = current_domain->domain;
    D.23689 = field->offset;
    D.23690 = (sizetype) D.23689;
    D.23695 = D.23694 + D.23690;
    current_appdomain_delegate = *D.23695;
    goto <D.23696>;
    <D.23693>:
    current_appdomain_delegate = 0B;
    <D.23696>:
    D.23697 = current_appdomain_delegate == 0B;
    D.23698 = root_appdomain_delegate == 0B;
    D.23699 = D.23697 & D.23698;
    if (D.23699 != 0) goto <D.23700>; else goto <D.23701>;
    <D.23700>:
    if (abort_process != 0) goto <D.23702>; else goto <D.23703>;
    <D.23702>:
    mono_environment_exitcode_set (1);
    <D.23703>:
    mono_print_unhandled_exception (exc);
    goto <D.23704>;
    <D.23701>:
    if (root_appdomain_delegate != 0B) goto <D.23705>; else goto <D.23706>;
    <D.23705>:
    call_unhandled_exception_delegate (root_domain, root_appdomain_delegate, exc);
    <D.23706>:
    if (current_appdomain_delegate != 0B) goto <D.23707>; else goto <D.23708>;
    <D.23707>:
    call_unhandled_exception_delegate (current_domain, current_appdomain_delegate, exc);
    <D.23708>:
    <D.23704>:
  }
  <D.23677>:
}


call_unhandled_exception_delegate (struct MonoDomain * domain, struct MonoObject * delegate, struct MonoObject * exc)
{
  struct MonoAppDomain * D.23711;
  struct MonoVTable * D.23712;
  struct MonoDomain * D.23713;
  _Bool D.23714;
  long int D.23715;
  long int D.23716;
  struct MonoVTable * D.23719;
  struct MonoDomain * D.23720;
  struct MonoObject * serialization_exc.123;
  _Bool D.23728;
  long int D.23729;
  long int D.23730;
  struct MonoImage * D.23734;
  _Bool D.23735;
  long int D.23736;
  long int D.23737;
  struct MonoObject * D.23740;
  struct MonoObject * e.124;
  struct MonoString * D.23746;
  int D.23747;
  struct MonoObject * e;
  void * pa[2];
  struct MonoDomain * current_domain;

  try
    {
      e = 0B;
      current_domain = mono_domain_get ();
      if (domain != current_domain) goto <D.23709>; else goto <D.23710>;
      <D.23709>:
      mono_domain_set_internal_with_options (domain, 0);
      <D.23710>:
      D.23711 = domain->domain;
      D.23712 = MEM[(struct MonoObject *)D.23711].vtable;
      D.23713 = D.23712->domain;
      D.23714 = D.23713 != domain;
      D.23715 = (long int) D.23714;
      D.23716 = __builtin_expect (D.23715, 0);
      if (D.23716 != 0) goto <D.23717>; else goto <D.23718>;
      <D.23717>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 3850, "domain == mono_object_domain (domain->domain)");
      <D.23718>:
      D.23719 = exc->vtable;
      D.23720 = D.23719->domain;
      if (D.23720 != domain) goto <D.23721>; else goto <D.23722>;
      <D.23721>:
      {
        struct MonoObject * serialization_exc;

        try
          {
            exc = mono_object_xdomain_representation (exc, domain, &serialization_exc);
            if (exc == 0B) goto <D.23723>; else goto <D.23724>;
            <D.23723>:
            serialization_exc.123 = serialization_exc;
            if (serialization_exc.123 != 0B) goto <D.23726>; else goto <D.23727>;
            <D.23726>:
            {
              struct MonoObject * dummy;

              try
                {
                  serialization_exc.123 = serialization_exc;
                  exc = mono_object_xdomain_representation (serialization_exc.123, domain, &dummy);
                  D.23728 = exc == 0B;
                  D.23729 = (long int) D.23728;
                  D.23730 = __builtin_expect (D.23729, 0);
                  if (D.23730 != 0) goto <D.23731>; else goto <D.23732>;
                  <D.23731>:
                  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 3860, "exc");
                  <D.23732>:
                }
              finally
                {
                  dummy = {CLOBBER};
                }
            }
            goto <D.23733>;
            <D.23727>:
            D.23734 = mono_get_corlib ();
            exc = mono_exception_from_name_msg (D.23734, "System.Runtime.Serialization", "SerializationException", "Could not serialize unhandled exception.");
            <D.23733>:
            <D.23724>:
          }
        finally
          {
            serialization_exc = {CLOBBER};
          }
      }
      <D.23722>:
      D.23719 = exc->vtable;
      D.23720 = D.23719->domain;
      D.23735 = D.23720 != domain;
      D.23736 = (long int) D.23735;
      D.23737 = __builtin_expect (D.23736, 0);
      if (D.23737 != 0) goto <D.23738>; else goto <D.23739>;
      <D.23738>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 3868, "mono_object_domain (exc) == domain");
      <D.23739>:
      D.23711 = domain->domain;
      pa[0] = D.23711;
      D.23740 = create_unhandled_exception_eventargs (exc);
      pa[1] = D.23740;
      mono_runtime_delegate_invoke (delegate, &pa, &e);
      if (domain != current_domain) goto <D.23741>; else goto <D.23742>;
      <D.23741>:
      mono_domain_set_internal_with_options (current_domain, 0);
      <D.23742>:
      e.124 = e;
      if (e.124 != 0B) goto <D.23744>; else goto <D.23745>;
      <D.23744>:
      {
        struct MonoError error;
        gchar * msg;

        try
          {
            e.124 = e;
            D.23746 = MEM[(struct MonoException *)e.124].message;
            msg = mono_string_to_utf8_checked (D.23746, &error);
            D.23747 = mono_error_ok (&error);
            if (D.23747 == 0) goto <D.23748>; else goto <D.23749>;
            <D.23748>:
            monoeg_g_log (0B, 16, "Exception inside UnhandledException handler with invalid message (Invalid characters)\n");
            mono_error_cleanup (&error);
            goto <D.23750>;
            <D.23749>:
            monoeg_g_log (0B, 16, "exception inside UnhandledException handler: %s\n", msg);
            monoeg_g_free (msg);
            <D.23750>:
          }
        finally
          {
            error = {CLOBBER};
          }
      }
      <D.23745>:
    }
  finally
    {
      e = {CLOBBER};
      pa = {CLOBBER};
    }
}


create_unhandled_exception_eventargs (struct MonoObject * exc)
{
  struct MonoImage * D.23751;
  _Bool D.23752;
  long int D.23753;
  long int D.23754;
  _Bool D.23757;
  long int D.23758;
  long int D.23759;
  struct MonoDomain * D.23762;
  struct MonoObject * D.23763;
  struct MonoClass * klass;
  void * args[2];
  struct MonoMethod * method;
  MonoBoolean is_terminating;
  struct MonoObject * obj;

  try
    {
      method = 0B;
      is_terminating = 1;
      D.23751 = mono_defaults.corlib;
      klass = mono_class_from_name (D.23751, "System", "UnhandledExceptionEventArgs");
      D.23752 = klass == 0B;
      D.23753 = (long int) D.23752;
      D.23754 = __builtin_expect (D.23753, 0);
      if (D.23754 != 0) goto <D.23755>; else goto <D.23756>;
      <D.23755>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 3823, "klass");
      <D.23756>:
      mono_class_init (klass);
      method = mono_class_get_method_from_name_flags (klass, ".ctor", 2, 6);
      D.23757 = method == 0B;
      D.23758 = (long int) D.23757;
      D.23759 = __builtin_expect (D.23758, 0);
      if (D.23759 != 0) goto <D.23760>; else goto <D.23761>;
      <D.23760>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 3829, "method");
      <D.23761>:
      args[0] = exc;
      args[1] = &is_terminating;
      D.23762 = mono_domain_get ();
      obj = mono_object_new (D.23762, klass);
      mono_runtime_invoke (method, obj, &args, 0B);
      D.23763 = obj;
      return D.23763;
    }
  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.23766;
  long int D.23767;
  long int D.23768;
  struct MonoVTable * D.23771;
  struct MonoAssembly * D.23772;
  struct MonoClass * D.23775;
  struct MonoImage * D.23776;
  struct MonoAppDomainSetup * D.23777;
  struct MonoString * D.23778;
  char * D.23781;
  struct MonoString * D.23782;
  struct MonoString * * D.23783;
  struct MonoString * D.23784;
  struct MonoImage * D.23787;
  char * D.23788;
  struct MonoString * D.23789;
  struct MonoString * * D.23790;
  struct MonoClass * stathread_attribute.125;
  struct MonoImage * D.23796;
  struct MonoClass * stathread_attribute.126;
  int D.23798;
  struct MonoMethodSignature * D.23805;
  struct MonoType * D.23806;
  unsigned char D.23807;
  struct MonoObject * D.23814;
  guint32 * D.23815;
  unsigned int D.23816;
  int D.23822;
  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.23766 = args == 0B;
      D.23767 = (long int) D.23766;
      D.23768 = __builtin_expect (D.23767, 0);
      if (D.23768 != 0) goto <D.23769>; else goto <D.23770>;
      <D.23769>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 4008, "args");
      <D.23770>:
      pa[0] = args;
      D.23771 = MEM[(struct MonoObject *)args].vtable;
      domain = D.23771->domain;
      D.23772 = domain->entry_assembly;
      if (D.23772 == 0B) goto <D.23773>; else goto <D.23774>;
      <D.23773>:
      {
        gchar * str;
        struct MonoAssembly * assembly;

        D.23775 = method->klass;
        D.23776 = D.23775->image;
        assembly = D.23776->assembly;
        domain->entry_assembly = assembly;
        D.23777 = domain->setup;
        D.23778 = D.23777->application_base;
        if (D.23778 == 0B) goto <D.23779>; else goto <D.23780>;
        <D.23779>:
        D.23781 = assembly->basedir;
        D.23782 = mono_string_new (domain, D.23781);
        D.23777 = domain->setup;
        D.23783 = &D.23777->application_base;
        D.23777 = domain->setup;
        mono_gc_wbarrier_set_field (D.23777, D.23783, D.23782);
        <D.23780>:
        D.23777 = domain->setup;
        D.23784 = D.23777->configuration_file;
        if (D.23784 == 0B) goto <D.23785>; else goto <D.23786>;
        <D.23785>:
        D.23787 = assembly->image;
        D.23788 = D.23787->name;
        str = monoeg_g_strconcat (D.23788, ".config", 0B);
        D.23789 = mono_string_new (domain, str);
        D.23777 = domain->setup;
        D.23790 = &D.23777->configuration_file;
        D.23777 = domain->setup;
        mono_gc_wbarrier_set_field (D.23777, D.23790, D.23789);
        monoeg_g_free (str);
        mono_set_private_bin_path_from_config (domain);
        <D.23786>:
      }
      <D.23774>:
      cinfo = mono_custom_attrs_from_method (method);
      if (cinfo != 0B) goto <D.23791>; else goto <D.23792>;
      <D.23791>:
      {
        static struct MonoClass * stathread_attribute = 0B;

        stathread_attribute.125 = stathread_attribute;
        if (stathread_attribute.125 == 0B) goto <D.23794>; else goto <D.23795>;
        <D.23794>:
        D.23796 = mono_defaults.corlib;
        stathread_attribute.126 = mono_class_from_name (D.23796, "System", "STAThreadAttribute");
        stathread_attribute = stathread_attribute.126;
        <D.23795>:
        stathread_attribute.125 = stathread_attribute;
        has_stathread_attribute = mono_custom_attrs_has_attr (cinfo, stathread_attribute.125);
        D.23798 = cinfo->cached;
        if (D.23798 == 0) goto <D.23799>; else goto <D.23800>;
        <D.23799>:
        mono_custom_attrs_free (cinfo);
        <D.23800>:
      }
      goto <D.23801>;
      <D.23792>:
      has_stathread_attribute = 0;
      <D.23801>:
      if (has_stathread_attribute != 0) goto <D.23802>; else goto <D.23803>;
      <D.23802>:
      thread->apartment_state = 0;
      goto <D.23804>;
      <D.23803>:
      thread->apartment_state = 1;
      <D.23804>:
      mono_thread_init_apartment_state ();
      D.23805 = mono_method_signature (method);
      D.23806 = D.23805->ret;
      D.23807 = D.23806->type;
      if (D.23807 == 8) goto <D.23808>; else goto <D.23809>;
      <D.23808>:
      {
        struct MonoObject * res;

        res = mono_runtime_invoke (method, 0B, &pa, exc);
        if (exc == 0B) goto <D.23810>; else goto <D.23813>;
        <D.23813>:
        D.23814 = *exc;
        if (D.23814 == 0B) goto <D.23810>; else goto <D.23811>;
        <D.23810>:
        D.23815 = res + 16;
        D.23816 = *D.23815;
        rval = (int) D.23816;
        goto <D.23812>;
        <D.23811>:
        rval = -1;
        <D.23812>:
        mono_environment_exitcode_set (rval);
      }
      goto <D.23817>;
      <D.23809>:
      mono_runtime_invoke (method, 0B, &pa, exc);
      if (exc == 0B) goto <D.23818>; else goto <D.23821>;
      <D.23821>:
      D.23814 = *exc;
      if (D.23814 == 0B) goto <D.23818>; else goto <D.23819>;
      <D.23818>:
      rval = 0;
      goto <D.23820>;
      <D.23819>:
      rval = -1;
      mono_environment_exitcode_set (rval);
      <D.23820>:
      <D.23817>:
      D.23822 = rval;
      return D.23822;
    }
  finally
    {
      pa = {CLOBBER};
    }
}


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

  if (func != 0B) goto <D.23826>; else goto <D.23827>;
  <D.23826>:
  iftmp.127 = func;
  goto <D.23828>;
  <D.23827>:
  iftmp.127 = dummy_mono_runtime_invoke;
  <D.23828>:
  default_mono_runtime_invoke = iftmp.127;
}


mono_runtime_invoke_array (struct MonoMethod * method, void * obj, struct MonoArray * params, struct MonoObject * * exc)
{
  long unsigned int D.23831;
  long unsigned int D.23832;
  unsigned char D.23833;
  int D.23834;
  struct MonoType * D.23838;
  struct MonoClass * D.23839;
  int D.23840;
  long unsigned int D.23842;
  long unsigned int D.23843;
  void * * D.23844;
  long unsigned int D.23845;
  char * D.23846;
  struct MonoObject * D.23847;
  unsigned char D.23848;
  unsigned char D.23849;
  char * D.23852;
  struct MonoObject * D.23853;
  struct MonoClass * D.23856;
  struct MonoDomain * D.23857;
  struct MonoObject * D.23858;
  char * D.23861;
  void * D.23862;
  struct MonoVTable * D.23863;
  struct MonoClass * D.23864;
  struct MonoDomain * D.23865;
  char * D.23866;
  struct MonoObject * D.23867;
  void * D.23868;
  char * D.23871;
  char * D.23873;
  struct MonoObject * D.23874;
  struct MonoGenericClass * D.23877;
  struct MonoClass * D.23878;
  char * D.23880;
  struct MonoVTable * D.23884;
  struct MonoClass * D.23885;
  struct MonoClass * D.23886;
  _Bool D.23887;
  long int D.23888;
  long int D.23889;
  void * D.23892;
  unsigned char D.23893;
  int D.23894;
  long unsigned int D.23895;
  int D.20159;
  int iftmp.128;
  int D.20158;
  const char[6] * D.23900;
  unsigned char D.23901;
  int D.23902;
  unsigned char D.23903;
  int D.23904;
  _Bool D.23905;
  _Bool D.23906;
  _Bool D.23907;
  const unsigned char * D.23910;
  unsigned char D.23911;
  int D.23912;
  const unsigned char * D.23913;
  unsigned char D.23914;
  int D.23915;
  _Bool D.23916;
  _Bool D.23917;
  const unsigned char * D.23920;
  unsigned char D.23921;
  int D.23922;
  const unsigned char * D.23923;
  unsigned char D.23924;
  int D.23925;
  _Bool D.23926;
  _Bool D.23927;
  const unsigned char * D.23930;
  unsigned char D.23931;
  int D.23932;
  const unsigned char * D.23933;
  unsigned char D.23934;
  int D.23935;
  const char * D.23937;
  struct MonoClass * D.23939;
  struct MonoClass * D.23940;
  int D.23942;
  _Bool D.23945;
  long int D.23946;
  long int D.23947;
  struct MonoObject * D.23952;
  void * D.23953;
  struct MonoClass * D.23954;
  struct MonoDomain * D.23955;
  struct MonoDomain * D.23958;
  _Bool D.23959;
  long int D.23960;
  long int D.23961;
  struct MonoVTable * D.23964;
  struct MonoClass * D.23965;
  struct MonoClass * D.23966;
  struct MonoMethod * iftmp.129;
  short int D.23970;
  struct MonoMethod * * D.23973;
  long unsigned int D.23974;
  long unsigned int D.23975;
  struct MonoMethod * * D.23976;
  unsigned char D.23978;
  unsigned char D.23979;
  struct MonoDomain * D.23986;
  int D.23987;
  struct MonoDomain * D.23990;
  struct MonoDomain * D.23991;
  struct MonoObject * D.23992;
  void * D.23993;
  struct MonoType * D.23994;
  unsigned char D.23995;
  struct MonoClass * pointer_class.132;
  struct MonoClass * tmp_klass.130;
  struct MonoImage * D.24003;
  struct MonoClass * tmp_klass.131;
  _Bool D.24005;
  long int D.24006;
  long int D.24007;
  struct MonoMethod * box_method.133;
  struct MonoMethod * box_method.134;
  struct MonoVTable * D.24014;
  struct MonoClass * D.24015;
  _Bool D.24016;
  long int D.24017;
  long int D.24018;
  void * D.24021;
  struct MonoDomain * D.24022;
  struct MonoReflectionType * D.24023;
  struct MonoObject * box_exc.135;
  _Bool D.24025;
  long int D.24026;
  long int D.24027;
  short unsigned int D.24032;
  short unsigned int D.24033;
  struct MonoClass * D.24036;
  int D.24037;
  void * D.24040;
  long unsigned int D.24041;
  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.23829>; else goto <D.23830>;
  <D.23829>:
  D.23831 = mono_array_length (params);
  D.23832 = D.23831 * 8;
  pa = __builtin_alloca (D.23832);
  i = 0;
  goto <D.20149>;
  <D.20148>:
  {
    struct MonoType * t;

    t = sig->params[i];
    again:
    D.23833 = t->type;
    D.23834 = (int) D.23833;
    switch (D.23834) <default: <D.20146>, case 2: <D.20120>, case 3: <D.20123>, case 4: <D.20119>, case 5: <D.20118>, case 6: <D.20122>, case 7: <D.20121>, case 8: <D.20127>, case 9: <D.20126>, case 10: <D.20129>, case 11: <D.20128>, case 12: <D.20130>, case 13: <D.20131>, case 14: <D.20138>, case 15: <D.20144>, case 17: <D.20132>, case 18: <D.20140>, case 20: <D.20141>, case 21: <D.20143>, case 24: <D.20125>, case 25: <D.20124>, case 28: <D.20139>, case 29: <D.20142>>
    <D.20118>:
    <D.20119>:
    <D.20120>:
    <D.20121>:
    <D.20122>:
    <D.20123>:
    <D.20124>:
    <D.20125>:
    <D.20126>:
    <D.20127>:
    <D.20128>:
    <D.20129>:
    <D.20130>:
    <D.20131>:
    <D.20132>:
    D.23833 = t->type;
    if (D.23833 == 17) goto <D.23837>; else goto <D.23835>;
    <D.23837>:
    D.23838 = sig->params[i];
    D.23839 = mono_class_from_mono_type (D.23838);
    D.23840 = mono_class_is_nullable (D.23839);
    if (D.23840 != 0) goto <D.23841>; else goto <D.23835>;
    <D.23841>:
    D.23842 = (long unsigned int) i;
    D.23843 = D.23842 * 8;
    D.23844 = pa + D.23843;
    D.23845 = (long unsigned int) i;
    D.23846 = mono_array_addr_with_size (params, 8, D.23845);
    D.23847 = MEM[(struct MonoObject * *)D.23846];
    *D.23844 = D.23847;
    D.23848 = BIT_FIELD_REF <*t, 8, 88>;
    D.23849 = D.23848 & 64;
    if (D.23849 != 0) goto <D.23850>; else goto <D.23851>;
    <D.23850>:
    has_byref_nullables = 1;
    <D.23851>:
    goto <D.23836>;
    <D.23835>:
    D.23845 = (long unsigned int) i;
    D.23852 = mono_array_addr_with_size (params, 8, D.23845);
    D.23853 = MEM[(struct MonoObject * *)D.23852];
    if (D.23853 == 0B) goto <D.23854>; else goto <D.23855>;
    <D.23854>:
    {
      void * * __p;

      D.23845 = (long unsigned int) i;
      __p = mono_array_addr_with_size (params, 8, D.23845);
      D.23838 = sig->params[i];
      D.23856 = mono_class_from_mono_type (D.23838);
      D.23857 = mono_domain_get ();
      D.23858 = mono_object_new (D.23857, D.23856);
      mono_gc_wbarrier_set_arrayref (params, __p, D.23858);
    }
    <D.23855>:
    D.23848 = BIT_FIELD_REF <*t, 8, 88>;
    D.23849 = D.23848 & 64;
    if (D.23849 != 0) goto <D.23859>; else goto <D.23860>;
    <D.23859>:
    {
      struct MonoObject * orig;
      struct MonoObject * copy;

      D.23845 = (long unsigned int) i;
      D.23861 = mono_array_addr_with_size (params, 8, D.23845);
      orig = MEM[(struct MonoObject * *)D.23861];
      D.23862 = mono_object_unbox (orig);
      D.23863 = orig->vtable;
      D.23864 = D.23863->klass;
      D.23865 = mono_domain_get ();
      copy = mono_value_box (D.23865, D.23864, D.23862);
      {
        void * * __p;

        D.23845 = (long unsigned int) i;
        __p = mono_array_addr_with_size (params, 8, D.23845);
        mono_gc_wbarrier_set_arrayref (params, __p, copy);
      }
    }
    <D.23860>:
    D.23842 = (long unsigned int) i;
    D.23843 = D.23842 * 8;
    D.23844 = pa + D.23843;
    D.23845 = (long unsigned int) i;
    D.23866 = mono_array_addr_with_size (params, 8, D.23845);
    D.23867 = MEM[(struct MonoObject * *)D.23866];
    D.23868 = mono_object_unbox (D.23867);
    *D.23844 = D.23868;
    <D.23836>:
    goto <D.20137>;
    <D.20138>:
    <D.20139>:
    <D.20140>:
    <D.20141>:
    <D.20142>:
    D.23848 = BIT_FIELD_REF <*t, 8, 88>;
    D.23849 = D.23848 & 64;
    if (D.23849 != 0) goto <D.23869>; else goto <D.23870>;
    <D.23869>:
    D.23842 = (long unsigned int) i;
    D.23843 = D.23842 * 8;
    D.23844 = pa + D.23843;
    D.23845 = (long unsigned int) i;
    D.23871 = mono_array_addr_with_size (params, 8, D.23845);
    *D.23844 = D.23871;
    goto <D.23872>;
    <D.23870>:
    D.23842 = (long unsigned int) i;
    D.23843 = D.23842 * 8;
    D.23844 = pa + D.23843;
    D.23845 = (long unsigned int) i;
    D.23873 = mono_array_addr_with_size (params, 8, D.23845);
    D.23874 = MEM[(struct MonoObject * *)D.23873];
    *D.23844 = D.23874;
    <D.23872>:
    goto <D.20137>;
    <D.20143>:
    D.23848 = BIT_FIELD_REF <*t, 8, 88>;
    D.23849 = D.23848 & 64;
    if (D.23849 != 0) goto <D.23875>; else goto <D.23876>;
    <D.23875>:
    D.23877 = t->data.generic_class;
    D.23878 = D.23877->container_class;
    t = &D.23878->this_arg;
    goto <D.23879>;
    <D.23876>:
    D.23877 = t->data.generic_class;
    D.23878 = D.23877->container_class;
    t = &D.23878->byval_arg;
    <D.23879>:
    goto again;
    <D.20144>:
    {
      struct MonoObject * arg;

      D.23845 = (long unsigned int) i;
      D.23880 = mono_array_addr_with_size (params, 8, D.23845);
      arg = MEM[(struct MonoObject * *)D.23880];
      if (arg == 0B) goto <D.23881>; else goto <D.23882>;
      <D.23881>:
      D.23842 = (long unsigned int) i;
      D.23843 = D.23842 * 8;
      D.23844 = pa + D.23843;
      *D.23844 = 0B;
      goto <D.23883>;
      <D.23882>:
      D.23884 = arg->vtable;
      D.23885 = D.23884->klass;
      D.23886 = mono_defaults.int_class;
      D.23887 = D.23885 != D.23886;
      D.23888 = (long int) D.23887;
      D.23889 = __builtin_expect (D.23888, 0);
      if (D.23889 != 0) goto <D.23890>; else goto <D.23891>;
      <D.23890>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 4211, "arg->vtable->klass == mono_defaults.int_class");
      <D.23891>:
      D.23842 = (long unsigned int) i;
      D.23843 = D.23842 * 8;
      D.23844 = pa + D.23843;
      D.23892 = MEM[(struct MonoIntPtr *)arg].m_value;
      *D.23844 = D.23892;
      <D.23883>:
      goto <D.20137>;
    }
    <D.20146>:
    D.23838 = sig->params[i];
    D.23893 = D.23838->type;
    D.23894 = (int) D.23893;
    monoeg_g_log (0B, 4, "type 0x%x not handled in mono_runtime_invoke_array", D.23894);
    <D.20147>:
    goto <D.20147>;
    <D.20137>:
  }
  i = i + 1;
  <D.20149>:
  D.23845 = (long unsigned int) i;
  D.23895 = mono_array_length (params);
  if (D.23845 < D.23895) goto <D.20148>; else goto <D.20150>;
  <D.20150>:
  <D.23830>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = method->name;
      D.23900 = ".ctor";
      D.23901 = MEM[(const unsigned char *)D.23900];
      D.23902 = (int) D.23901;
      D.23903 = *__s2;
      D.23904 = (int) D.23903;
      __result = D.23902 - D.23904;
      {
        D.23905 = __s2_len != 0;
        D.23906 = __result == 0;
        D.23907 = D.23905 & D.23906;
        if (D.23907 != 0) goto <D.23908>; else goto <D.23909>;
        <D.23908>:
        D.23910 = &MEM[(void *)".ctor" + 1B];
        D.23911 = *D.23910;
        D.23912 = (int) D.23911;
        D.23913 = __s2 + 1;
        D.23914 = *D.23913;
        D.23915 = (int) D.23914;
        __result = D.23912 - D.23915;
        D.23916 = __s2_len > 1;
        D.23906 = __result == 0;
        D.23917 = D.23916 & D.23906;
        if (D.23917 != 0) goto <D.23918>; else goto <D.23919>;
        <D.23918>:
        D.23920 = &MEM[(void *)".ctor" + 2B];
        D.23921 = *D.23920;
        D.23922 = (int) D.23921;
        D.23923 = __s2 + 2;
        D.23924 = *D.23923;
        D.23925 = (int) D.23924;
        __result = D.23922 - D.23925;
        D.23926 = __s2_len > 2;
        D.23906 = __result == 0;
        D.23927 = D.23926 & D.23906;
        if (D.23927 != 0) goto <D.23928>; else goto <D.23929>;
        <D.23928>:
        D.23930 = &MEM[(void *)".ctor" + 3B];
        D.23931 = *D.23930;
        D.23932 = (int) D.23931;
        D.23933 = __s2 + 3;
        D.23934 = *D.23933;
        D.23935 = (int) D.23934;
        __result = D.23932 - D.23935;
        <D.23929>:
        <D.23919>:
        <D.23909>:
      }
      D.20158 = __result;
    }
    iftmp.128 = -D.20158;
    goto <D.23936>;
    <D.23899>:
    D.23937 = method->name;
    iftmp.128 = __builtin_strcmp (D.23937, ".ctor");
    <D.23936>:
    D.20159 = iftmp.128;
  }
  if (D.20159 == 0) goto <D.23938>; else goto <D.23896>;
  <D.23938>:
  D.23939 = method->klass;
  D.23940 = mono_defaults.string_class;
  if (D.23939 != D.23940) goto <D.23941>; else goto <D.23896>;
  <D.23941>:
  {
    void * o;

    o = obj;
    D.23939 = method->klass;
    D.23942 = mono_class_is_nullable (D.23939);
    if (D.23942 != 0) goto <D.23943>; else goto <D.23944>;
    <D.23943>:
    D.23945 = obj != 0B;
    D.23946 = (long int) D.23945;
    D.23947 = __builtin_expect (D.23946, 0);
    if (D.23947 != 0) goto <D.23948>; else goto <D.23949>;
    <D.23948>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 4227, "!obj");
    <D.23949>:
    if (params == 0B) goto <D.23950>; else goto <D.23951>;
    <D.23950>:
    D.23952 = 0B;
    return D.23952;
    <D.23951>:
    D.23953 = *pa;
    D.23939 = method->klass;
    D.23954 = D.23939->cast_class;
    D.23955 = mono_domain_get ();
    D.23952 = mono_value_box (D.23955, D.23954, D.23953);
    return D.23952;
    <D.23944>:
    if (obj == 0B) goto <D.23956>; else goto <D.23957>;
    <D.23956>:
    D.23939 = method->klass;
    D.23958 = mono_domain_get ();
    obj = mono_object_new (D.23958, D.23939);
    D.23959 = obj == 0B;
    D.23960 = (long int) D.23959;
    D.23961 = __builtin_expect (D.23960, 0);
    if (D.23961 != 0) goto <D.23962>; else goto <D.23963>;
    <D.23962>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 4237, "obj");
    <D.23963>:
    D.23964 = MEM[(struct MonoObject *)obj].vtable;
    D.23965 = D.23964->klass;
    D.23966 = mono_defaults.transparent_proxy_class;
    if (D.23965 == D.23966) goto <D.23967>; else goto <D.23968>;
    <D.23967>:
    D.23970 = method->slot;
    if (D.23970 != -1) goto <D.23971>; else goto <D.23972>;
    <D.23971>:
    D.23939 = method->klass;
    D.23973 = D.23939->vtable;
    D.23970 = method->slot;
    D.23974 = (long unsigned int) D.23970;
    D.23975 = D.23974 * 8;
    D.23976 = D.23973 + D.23975;
    iftmp.129 = *D.23976;
    goto <D.23977>;
    <D.23972>:
    iftmp.129 = method;
    <D.23977>:
    method = mono_marshal_get_remoting_invoke (iftmp.129);
    <D.23968>:
    D.23939 = method->klass;
    D.23978 = BIT_FIELD_REF <*D.23939, 8, 256>;
    D.23979 = D.23978 & 8;
    if (D.23979 != 0) goto <D.23980>; else goto <D.23981>;
    <D.23980>:
    o = mono_object_unbox (obj);
    goto <D.23982>;
    <D.23981>:
    o = obj;
    <D.23982>:
    goto <D.23983>;
    <D.23957>:
    D.23939 = method->klass;
    D.23978 = BIT_FIELD_REF <*D.23939, 8, 256>;
    D.23979 = D.23978 & 8;
    if (D.23979 != 0) goto <D.23984>; else goto <D.23985>;
    <D.23984>:
    D.23939 = method->klass;
    D.23986 = mono_domain_get ();
    obj = mono_value_box (D.23986, D.23939, obj);
    <D.23985>:
    <D.23983>:
    mono_runtime_invoke (method, o, pa, exc);
    D.23952 = obj;
    return D.23952;
  }
  <D.23896>:
  D.23939 = method->klass;
  D.23987 = mono_class_is_nullable (D.23939);
  if (D.23987 != 0) goto <D.23988>; else goto <D.23989>;
  <D.23988>:
  {
    struct MonoObject * nullable;

    D.23939 = method->klass;
    D.23990 = mono_domain_get ();
    nullable = mono_object_new (D.23990, D.23939);
    D.23939 = method->klass;
    D.23939 = method->klass;
    D.23954 = D.23939->cast_class;
    D.23991 = mono_domain_get ();
    D.23992 = mono_value_box (D.23991, D.23954, obj);
    D.23993 = mono_object_unbox (nullable);
    mono_nullable_init (D.23993, D.23992, D.23939);
    obj = mono_object_unbox (nullable);
  }
  <D.23989>:
  res = mono_runtime_invoke (method, obj, pa, exc);
  D.23994 = sig->ret;
  D.23995 = D.23994->type;
  if (D.23995 == 15) goto <D.23996>; else goto <D.23997>;
  <D.23996>:
  {
    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.130 = tmp_klass;
            if (tmp_klass.130 == 0B) goto <D.23999>; else goto <D.24000>;
            <D.23999>:
            if (0 != 0) goto <D.24001>; else goto <D.24002>;
            <D.24001>:
            monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 4277, "mono_defaults.corlib == mono_defaults.corlib");
            <D.24002>:
            D.24003 = mono_defaults.corlib;
            tmp_klass.131 = mono_class_from_name (D.24003, "System.Reflection", "Pointer");
            tmp_klass = tmp_klass.131;
            tmp_klass.130 = tmp_klass;
            D.24005 = tmp_klass.130 == 0B;
            D.24006 = (long int) D.24005;
            D.24007 = __builtin_expect (D.24006, 0);
            if (D.24007 != 0) goto <D.24008>; else goto <D.24009>;
            <D.24008>:
            monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 4277, "tmp_klass");
            <D.24009>:
            <D.24000>:
          }
          pointer_class.132 = tmp_klass;
        }
        pointer_class = pointer_class.132;
        box_method.133 = box_method;
        if (box_method.133 == 0B) goto <D.24011>; else goto <D.24012>;
        <D.24011>:
        box_method.134 = mono_class_get_method_from_name (pointer_class, "Box", -1);
        box_method = box_method.134;
        <D.24012>:
        D.24014 = res->vtable;
        D.24015 = D.24014->klass;
        D.23886 = mono_defaults.int_class;
        D.24016 = D.24015 != D.23886;
        D.24017 = (long int) D.24016;
        D.24018 = __builtin_expect (D.24017, 0);
        if (D.24018 != 0) goto <D.24019>; else goto <D.24020>;
        <D.24019>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 4281, "res->vtable->klass == mono_defaults.int_class");
        <D.24020>:
        D.24021 = MEM[(struct MonoIntPtr *)res].m_value;
        box_args[0] = D.24021;
        D.23994 = sig->ret;
        D.24022 = mono_domain_get ();
        D.24023 = mono_type_get_object (D.24022, D.23994);
        box_args[1] = D.24023;
        box_method.133 = box_method;
        res = mono_runtime_invoke (box_method.133, 0B, &box_args, &box_exc);
        box_exc.135 = box_exc;
        D.24025 = box_exc.135 != 0B;
        D.24026 = (long int) D.24025;
        D.24027 = __builtin_expect (D.24026, 0);
        if (D.24027 != 0) goto <D.24028>; else goto <D.24029>;
        <D.24028>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 4285, "!box_exc");
        <D.24029>:
      }
    finally
      {
        box_args = {CLOBBER};
        box_exc = {CLOBBER};
      }
  }
  <D.23997>:
  if (has_byref_nullables != 0) goto <D.24030>; else goto <D.24031>;
  <D.24030>:
  i = 0;
  goto <D.20171>;
  <D.20170>:
  {
    struct MonoType * t;

    t = sig->params[i];
    D.24032 = BIT_FIELD_REF <*t, 16, 80>;
    D.24033 = D.24032 & 16639;
    if (D.24033 == 16405) goto <D.24034>; else goto <D.24035>;
    <D.24034>:
    D.24036 = mono_class_from_mono_type (t);
    D.24037 = mono_class_is_nullable (D.24036);
    if (D.24037 != 0) goto <D.24038>; else goto <D.24039>;
    <D.24038>:
    {
      void * * __p;

      D.23845 = (long unsigned int) i;
      __p = mono_array_addr_with_size (params, 8, D.23845);
      D.23842 = (long unsigned int) i;
      D.23843 = D.23842 * 8;
      D.23844 = pa + D.23843;
      D.24040 = *D.23844;
      mono_gc_wbarrier_set_arrayref (params, __p, D.24040);
    }
    <D.24039>:
    <D.24035>:
  }
  i = i + 1;
  <D.20171>:
  D.23845 = (long unsigned int) i;
  D.24041 = mono_array_length (params);
  if (D.23845 < D.24041) goto <D.20170>; else goto <D.20172>;
  <D.20172>:
  <D.24031>:
  D.23952 = res;
  return D.23952;
}


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

  vtable = mono_class_vtable (domain, klass);
  if (vtable == 0B) goto <D.24043>; else goto <D.24044>;
  <D.24043>:
  D.24045 = 0B;
  return D.24045;
  <D.24044>:
  D.24045 = mono_object_new_specific (vtable);
  return D.24045;
}


mono_object_new_pinned (struct MonoDomain * domain, struct MonoClass * klass)
{
  struct MonoObject * D.24049;
  int D.24050;
  long unsigned int D.24051;
  struct MonoVTable * vtable;

  vtable = mono_class_vtable (domain, klass);
  if (vtable == 0B) goto <D.24047>; else goto <D.24048>;
  <D.24047>:
  D.24049 = 0B;
  return D.24049;
  <D.24048>:
  D.24050 = mono_class_instance_size (klass);
  D.24051 = (long unsigned int) D.24050;
  D.24049 = mono_gc_alloc_pinned_obj (vtable, D.24051);
  return D.24049;
}


mono_object_new_specific (struct MonoVTable * vtable)
{
  unsigned char D.24055;
  unsigned char D.24056;
  struct MonoClass * D.24058;
  unsigned char D.24059;
  unsigned char D.24060;
  struct MonoDomain * D.24061;
  struct MonoImage * D.24064;
  unsigned char D.24065;
  unsigned char D.24066;
  _Bool D.24069;
  long int D.24070;
  long int D.24071;
  struct MonoType * D.24074;
  struct MonoDomain * D.24075;
  struct MonoReflectionType * D.24076;
  struct MonoObject * D.24079;
  struct MonoObject * o;

  D.24055 = BIT_FIELD_REF <*vtable, 8, 344>;
  D.24056 = D.24055 & 1;
  if (D.24056 != 0) goto <D.24053>; else goto <D.24057>;
  <D.24057>:
  D.24058 = vtable->klass;
  D.24059 = BIT_FIELD_REF <*D.24058, 8, 280>;
  D.24060 = D.24059 & 64;
  if (D.24060 != 0) goto <D.24053>; else goto <D.24054>;
  <D.24053>:
  {
    void * pa[1];
    struct MonoMethod * im;

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

          D.24064 = mono_defaults.corlib;
          klass = mono_class_from_name (D.24064, "System.Runtime.Remoting.Activation", "ActivationServices");
          D.24065 = BIT_FIELD_REF <*klass, 8, 256>;
          D.24066 = D.24065 & 1;
          if (D.24066 == 0) goto <D.24067>; else goto <D.24068>;
          <D.24067>:
          mono_class_init (klass);
          <D.24068>:
          im = mono_class_get_method_from_name (klass, "CreateProxyForType", 1);
          D.24069 = im == 0B;
          D.24070 = (long int) D.24069;
          D.24071 = __builtin_expect (D.24070, 0);
          if (D.24071 != 0) goto <D.24072>; else goto <D.24073>;
          <D.24072>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 4430, "im");
          <D.24073>:
          D.24061 = vtable->domain;
          D.24061->create_proxy_for_type_method = im;
        }
        <D.24063>:
        D.24058 = vtable->klass;
        D.24074 = &D.24058->byval_arg;
        D.24075 = mono_domain_get ();
        D.24076 = mono_type_get_object (D.24075, D.24074);
        pa[0] = D.24076;
        o = mono_runtime_invoke (im, 0B, &pa, 0B);
        if (o != 0B) goto <D.24077>; else goto <D.24078>;
        <D.24077>:
        D.24079 = o;
        return D.24079;
        <D.24078>:
      }
    finally
      {
        pa = {CLOBBER};
      }
  }
  <D.24054>:
  D.24079 = mono_object_new_alloc_specific (vtable);
  return D.24079;
}


mono_object_new_alloc_specific (struct MonoVTable * vtable)
{
  struct MonoClass * D.24083;
  unsigned char D.24084;
  unsigned char D.24085;
  void * D.24089;
  int D.24092;
  long unsigned int D.24093;
  unsigned char D.24095;
  unsigned char D.24096;
  _Bool D.24097;
  long int D.24098;
  long int D.24099;
  int profile_allocs.136;
  _Bool D.24103;
  long int D.24104;
  long int D.24105;
  struct MonoObject * D.24108;
  struct MonoObject * o;

  D.24083 = vtable->klass;
  D.24084 = BIT_FIELD_REF <*D.24083, 8, 280>;
  D.24085 = D.24084 & 8;
  if (D.24085 == 0) goto <D.24086>; else goto <D.24087>;
  <D.24086>:
  o = mono_object_new_ptrfree (vtable);
  goto <D.24088>;
  <D.24087>:
  D.24089 = vtable->gc_descr;
  if (D.24089 != 0B) goto <D.24090>; else goto <D.24091>;
  <D.24090>:
  D.24083 = vtable->klass;
  D.24092 = D.24083->instance_size;
  D.24093 = (long unsigned int) D.24092;
  o = mono_object_allocate_spec (D.24093, vtable);
  goto <D.24094>;
  <D.24091>:
  D.24083 = vtable->klass;
  D.24092 = D.24083->instance_size;
  D.24093 = (long unsigned int) D.24092;
  o = mono_object_allocate (D.24093, vtable);
  <D.24094>:
  <D.24088>:
  D.24083 = vtable->klass;
  D.24095 = BIT_FIELD_REF <*D.24083, 8, 272>;
  D.24096 = D.24095 & 32;
  D.24097 = D.24096 != 0;
  D.24098 = (long int) D.24097;
  D.24099 = __builtin_expect (D.24098, 0);
  if (D.24099 != 0) goto <D.24100>; else goto <D.24101>;
  <D.24100>:
  mono_object_register_finalizer (o);
  <D.24101>:
  profile_allocs.136 = profile_allocs;
  D.24103 = profile_allocs.136 != 0;
  D.24104 = (long int) D.24103;
  D.24105 = __builtin_expect (D.24104, 0);
  if (D.24105 != 0) goto <D.24106>; else goto <D.24107>;
  <D.24106>:
  D.24083 = vtable->klass;
  mono_profiler_allocation (o, D.24083);
  <D.24107>:
  D.24108 = o;
  return D.24108;
}


mono_object_allocate_spec (size_t size, struct MonoVTable * vtable)
{
  long unsigned int D.24110;
  long unsigned int D.24111;
  void * D.24112;
  void * o;

  o = mono_gc_alloc_obj (vtable, size);
  D.24110 = mono_stats.new_object_count;
  D.24111 = D.24110 + 1;
  mono_stats.new_object_count = D.24111;
  D.24112 = o;
  return D.24112;
}


mono_object_allocate (size_t size, struct MonoVTable * vtable)
{
  long unsigned int D.24114;
  long unsigned int D.24115;
  void * D.24116;
  struct MonoObject * o;

  D.24114 = mono_stats.new_object_count;
  D.24115 = D.24114 + 1;
  mono_stats.new_object_count = D.24115;
  o = mono_gc_alloc_obj (vtable, size);
  D.24116 = o;
  return D.24116;
}


mono_object_new_fast (struct MonoVTable * vtable)
{
  struct MonoClass * D.24118;
  int D.24119;
  long unsigned int D.24120;
  struct MonoObject * D.24121;
  struct MonoObject * o;

  D.24118 = vtable->klass;
  D.24119 = D.24118->instance_size;
  D.24120 = (long unsigned int) D.24119;
  o = mono_gc_alloc_obj (vtable, D.24120);
  D.24121 = o;
  return D.24121;
}


mono_class_get_allocation_ftn (struct MonoVTable * vtable, gboolean for_box, gboolean * pass_size_in_words)
{
  <unnamed type> D.24123;
  unsigned int D.24124;
  struct MonoClass * D.24129;
  int D.24130;
  unsigned char D.24132;
  unsigned char D.24133;
  <unnamed type> D.24135;
  unsigned int D.24136;
  void * D.24137;
  unsigned char D.24138;
  unsigned char D.24139;
  void * D.24144;

  *pass_size_in_words = 0;
  D.24123 = mono_profiler_get_events ();
  D.24124 = D.24123 & 128;
  if (D.24124 == 0) goto <D.24125>; else goto <D.24126>;
  <D.24125>:
  profile_allocs = 0;
  <D.24126>:
  D.24129 = vtable->klass;
  D.24130 = mono_class_has_finalizer (D.24129);
  if (D.24130 != 0) goto <D.24127>; else goto <D.24131>;
  <D.24131>:
  D.24129 = vtable->klass;
  D.24132 = BIT_FIELD_REF <*D.24129, 8, 272>;
  D.24133 = D.24132 & 64;
  if (D.24133 != 0) goto <D.24127>; else goto <D.24134>;
  <D.24134>:
  D.24135 = mono_profiler_get_events ();
  D.24136 = D.24135 & 128;
  if (D.24136 != 0) goto <D.24127>; else goto <D.24128>;
  <D.24127>:
  D.24137 = mono_object_new_specific;
  return D.24137;
  <D.24128>:
  D.24129 = vtable->klass;
  D.24138 = BIT_FIELD_REF <*D.24129, 8, 280>;
  D.24139 = D.24138 & 8;
  if (D.24139 == 0) goto <D.24140>; else goto <D.24141>;
  <D.24140>:
  if (for_box != 0) goto <D.24142>; else goto <D.24143>;
  <D.24142>:
  D.24137 = mono_object_new_ptrfree_box;
  return D.24137;
  <D.24143>:
  D.24137 = mono_object_new_ptrfree;
  return D.24137;
  <D.24141>:
  D.24144 = vtable->gc_descr;
  if (D.24144 != 0B) goto <D.24145>; else goto <D.24146>;
  <D.24145>:
  D.24137 = mono_object_new_fast;
  return D.24137;
  <D.24146>:
  D.24137 = mono_object_new_specific;
  return D.24137;
}


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

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


mono_object_clone (struct MonoObject * obj)
{
  struct MonoVTable * D.24150;
  struct MonoClass * D.24151;
  unsigned char D.24152;
  struct MonoObject * D.24155;
  long unsigned int D.24156;
  unsigned char D.24157;
  unsigned char D.24158;
  long unsigned int D.24162;
  long unsigned int D.24163;
  const void * D.24164;
  void * D.24165;
  int profile_allocs.137;
  _Bool D.24167;
  long int D.24168;
  long int D.24169;
  unsigned char D.24172;
  unsigned char D.24173;
  struct MonoObject * o;
  int size;

  D.24150 = obj->vtable;
  D.24151 = D.24150->klass;
  size = D.24151->instance_size;
  D.24150 = obj->vtable;
  D.24151 = D.24150->klass;
  D.24152 = D.24151->rank;
  if (D.24152 != 0) goto <D.24153>; else goto <D.24154>;
  <D.24153>:
  D.24155 = mono_array_clone (obj);
  return D.24155;
  <D.24154>:
  D.24150 = obj->vtable;
  D.24156 = (long unsigned int) size;
  o = mono_object_allocate (D.24156, D.24150);
  D.24150 = obj->vtable;
  D.24151 = D.24150->klass;
  D.24157 = BIT_FIELD_REF <*D.24151, 8, 280>;
  D.24158 = D.24157 & 8;
  if (D.24158 != 0) goto <D.24159>; else goto <D.24160>;
  <D.24159>:
  mono_gc_wbarrier_object_copy (o, obj);
  goto <D.24161>;
  <D.24160>:
  {
    int size;

    D.24150 = obj->vtable;
    D.24151 = D.24150->klass;
    size = D.24151->instance_size;
    D.24162 = (long unsigned int) size;
    D.24163 = D.24162 + 18446744073709551600;
    D.24164 = obj + 16;
    D.24165 = o + 16;
    mono_gc_memmove_atomic (D.24165, D.24164, D.24163);
  }
  <D.24161>:
  profile_allocs.137 = profile_allocs;
  D.24167 = profile_allocs.137 != 0;
  D.24168 = (long int) D.24167;
  D.24169 = __builtin_expect (D.24168, 0);
  if (D.24169 != 0) goto <D.24170>; else goto <D.24171>;
  <D.24170>:
  D.24150 = obj->vtable;
  D.24151 = D.24150->klass;
  mono_profiler_allocation (o, D.24151);
  <D.24171>:
  D.24150 = obj->vtable;
  D.24151 = D.24150->klass;
  D.24172 = BIT_FIELD_REF <*D.24151, 8, 272>;
  D.24173 = D.24172 & 32;
  if (D.24173 != 0) goto <D.24174>; else goto <D.24175>;
  <D.24174>:
  mono_object_register_finalizer (o);
  <D.24175>:
  D.24155 = o;
  return D.24155;
}


mono_array_full_copy (struct MonoArray * src, struct MonoArray * dest)
{
  struct MonoVTable * D.24177;
  struct MonoVTable * D.24178;
  struct MonoClass * D.24179;
  _Bool D.24180;
  long int D.24181;
  long int D.24182;
  long unsigned int D.24185;
  _Bool D.24186;
  long int D.24187;
  long int D.24188;
  int D.24191;
  long unsigned int D.24192;
  struct MonoClass * D.24193;
  unsigned char D.24194;
  unsigned char D.24195;
  unsigned char D.24198;
  unsigned char D.24199;
  long unsigned int D.24202;
  int D.24203;
  double[0:] * D.24204;
  double[0:] * D.24206;
  long unsigned int D.24208;
  int D.24209;
  uintptr_t size;
  struct MonoClass * klass;

  D.24177 = src->obj.vtable;
  klass = D.24177->klass;
  D.24178 = dest->obj.vtable;
  D.24179 = D.24178->klass;
  D.24180 = D.24179 != klass;
  D.24181 = (long int) D.24180;
  D.24182 = __builtin_expect (D.24181, 0);
  if (D.24182 != 0) goto <D.24183>; else goto <D.24184>;
  <D.24183>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 4619, "klass == dest->obj.vtable->klass");
  <D.24184>:
  size = mono_array_length (src);
  D.24185 = mono_array_length (dest);
  D.24186 = D.24185 != size;
  D.24187 = (long int) D.24186;
  D.24188 = __builtin_expect (D.24187, 0);
  if (D.24188 != 0) goto <D.24189>; else goto <D.24190>;
  <D.24189>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 4622, "size == mono_array_length (dest)");
  <D.24190>:
  D.24191 = mono_array_element_size (klass);
  D.24192 = (long unsigned int) D.24191;
  size = D.24192 * size;
  D.24193 = klass->element_class;
  D.24194 = BIT_FIELD_REF <*D.24193, 8, 256>;
  D.24195 = D.24194 & 8;
  if (D.24195 != 0) goto <D.24196>; else goto <D.24197>;
  <D.24196>:
  D.24193 = klass->element_class;
  D.24198 = BIT_FIELD_REF <*D.24193, 8, 280>;
  D.24199 = D.24198 & 8;
  if (D.24199 != 0) goto <D.24200>; else goto <D.24201>;
  <D.24200>:
  D.24202 = mono_array_length (src);
  D.24203 = (int) D.24202;
  D.24204 = &src->vector;
  mono_value_copy_array (dest, 0, D.24204, D.24203);
  goto <D.24205>;
  <D.24201>:
  D.24204 = &src->vector;
  D.24206 = &dest->vector;
  mono_gc_memmove_atomic (D.24206, D.24204, size);
  <D.24205>:
  goto <D.24207>;
  <D.24197>:
  {
    void * * __p;
    void * * __s;

    __p = mono_array_addr_with_size (dest, 8, 0);
    __s = mono_array_addr_with_size (src, 8, 0);
    D.24208 = mono_array_length (src);
    D.24209 = (int) D.24208;
    mono_gc_wbarrier_arrayref_copy (__p, __s, D.24209);
  }
  <D.24207>:
}


mono_array_clone_in_domain (struct MonoDomain * domain, struct MonoArray * array)
{
  struct MonoVTable * D.24210;
  struct MonoArrayBounds * D.24211;
  long unsigned int size.138;
  int D.24215;
  long unsigned int D.24216;
  long unsigned int size.139;
  long unsigned int size.140;
  struct MonoClass * D.24219;
  unsigned char D.24220;
  unsigned char D.24221;
  unsigned char D.24224;
  unsigned char D.24225;
  long unsigned int D.24228;
  int D.24229;
  double[0:] * D.24230;
  double[0:] * D.24232;
  long unsigned int D.24234;
  int D.24235;
  struct MonoArray * D.24236;
  unsigned char D.24237;
  long unsigned int D.24238;
  long unsigned int D.24239;
  int D.24240;
  long unsigned int size.141;
  long unsigned int D.24242;
  uintptr_t * D.24243;
  struct MonoArrayBounds * D.24244;
  unsigned int D.24245;
  long unsigned int D.24246;
  long unsigned int size.142;
  long unsigned int D.24248;
  long unsigned int D.24249;
  long unsigned int D.24250;
  uintptr_t * D.24251;
  int D.24252;
  long unsigned int D.24253;
  long unsigned int D.24254;
  intptr_t * D.24255;
  long unsigned int D.24260;
  int D.24261;
  long unsigned int D.24264;
  int D.24265;
  struct MonoArray * o;
  uintptr_t size;
  uintptr_t i;
  uintptr_t * sizes;
  struct MonoClass * klass;

  try
    {
      D.24210 = array->obj.vtable;
      klass = D.24210->klass;
      D.24211 = array->bounds;
      if (D.24211 == 0B) goto <D.24212>; else goto <D.24213>;
      <D.24212>:
      size.138 = mono_array_length (array);
      size = size.138;
      o = mono_array_new_full (domain, klass, &size, 0B);
      D.24215 = mono_array_element_size (klass);
      D.24216 = (long unsigned int) D.24215;
      size.139 = size;
      size.140 = D.24216 * size.139;
      size = size.140;
      D.24219 = klass->element_class;
      D.24220 = BIT_FIELD_REF <*D.24219, 8, 256>;
      D.24221 = D.24220 & 8;
      if (D.24221 != 0) goto <D.24222>; else goto <D.24223>;
      <D.24222>:
      D.24219 = klass->element_class;
      D.24224 = BIT_FIELD_REF <*D.24219, 8, 280>;
      D.24225 = D.24224 & 8;
      if (D.24225 != 0) goto <D.24226>; else goto <D.24227>;
      <D.24226>:
      D.24228 = mono_array_length (array);
      D.24229 = (int) D.24228;
      D.24230 = &array->vector;
      mono_value_copy_array (o, 0, D.24230, D.24229);
      goto <D.24231>;
      <D.24227>:
      size.139 = size;
      D.24230 = &array->vector;
      D.24232 = &o->vector;
      mono_gc_memmove_atomic (D.24232, D.24230, size.139);
      <D.24231>:
      goto <D.24233>;
      <D.24223>:
      {
        void * * __p;
        void * * __s;

        __p = mono_array_addr_with_size (o, 8, 0);
        __s = mono_array_addr_with_size (array, 8, 0);
        D.24234 = mono_array_length (array);
        D.24235 = (int) D.24234;
        mono_gc_wbarrier_arrayref_copy (__p, __s, D.24235);
      }
      <D.24233>:
      D.24236 = o;
      return D.24236;
      <D.24213>:
      D.24237 = klass->rank;
      D.24238 = (long unsigned int) D.24237;
      D.24239 = D.24238 * 16;
      sizes = __builtin_alloca (D.24239);
      D.24240 = mono_array_element_size (klass);
      size.141 = (long unsigned int) D.24240;
      size = size.141;
      i = 0;
      goto <D.20261>;
      <D.20260>:
      D.24242 = i * 8;
      D.24243 = sizes + D.24242;
      D.24211 = array->bounds;
      D.24242 = i * 8;
      D.24244 = D.24211 + D.24242;
      D.24245 = D.24244->length;
      D.24246 = (long unsigned int) D.24245;
      *D.24243 = D.24246;
      D.24211 = array->bounds;
      D.24242 = i * 8;
      D.24244 = D.24211 + D.24242;
      D.24245 = D.24244->length;
      D.24246 = (long unsigned int) D.24245;
      size.139 = size;
      size.142 = D.24246 * size.139;
      size = size.142;
      D.24237 = klass->rank;
      D.24248 = (long unsigned int) D.24237;
      D.24249 = D.24248 + i;
      D.24250 = D.24249 * 8;
      D.24251 = sizes + D.24250;
      D.24211 = array->bounds;
      D.24242 = i * 8;
      D.24244 = D.24211 + D.24242;
      D.24252 = D.24244->lower_bound;
      D.24253 = (long unsigned int) D.24252;
      *D.24251 = D.24253;
      i = i + 1;
      <D.20261>:
      D.24237 = klass->rank;
      D.24248 = (long unsigned int) D.24237;
      if (D.24248 > i) goto <D.20260>; else goto <D.20262>;
      <D.20262>:
      D.24237 = klass->rank;
      D.24238 = (long unsigned int) D.24237;
      D.24254 = D.24238 * 8;
      D.24255 = sizes + D.24254;
      o = mono_array_new_full (domain, klass, sizes, D.24255);
      D.24219 = klass->element_class;
      D.24220 = BIT_FIELD_REF <*D.24219, 8, 256>;
      D.24221 = D.24220 & 8;
      if (D.24221 != 0) goto <D.24256>; else goto <D.24257>;
      <D.24256>:
      D.24219 = klass->element_class;
      D.24224 = BIT_FIELD_REF <*D.24219, 8, 280>;
      D.24225 = D.24224 & 8;
      if (D.24225 != 0) goto <D.24258>; else goto <D.24259>;
      <D.24258>:
      D.24260 = mono_array_length (array);
      D.24261 = (int) D.24260;
      D.24230 = &array->vector;
      mono_value_copy_array (o, 0, D.24230, D.24261);
      goto <D.24262>;
      <D.24259>:
      size.139 = size;
      D.24230 = &array->vector;
      D.24232 = &o->vector;
      mono_gc_memmove_atomic (D.24232, D.24230, size.139);
      <D.24262>:
      goto <D.24263>;
      <D.24257>:
      {
        void * * __p;
        void * * __s;

        __p = mono_array_addr_with_size (o, 8, 0);
        __s = mono_array_addr_with_size (array, 8, 0);
        D.24264 = mono_array_length (array);
        D.24265 = (int) D.24264;
        mono_gc_wbarrier_arrayref_copy (__p, __s, D.24265);
      }
      <D.24263>:
      D.24236 = o;
      return D.24236;
    }
  finally
    {
      size = {CLOBBER};
    }
}


mono_array_clone (struct MonoArray * array)
{
  struct MonoArray * D.24268;
  struct MonoVTable * D.24269;
  struct MonoDomain * D.24270;

  D.24269 = MEM[(struct MonoObject *)array].vtable;
  D.24270 = D.24269->domain;
  D.24268 = mono_array_clone_in_domain (D.24270, array);
  return D.24268;
}


mono_array_calc_byte_len (struct MonoClass * class, uintptr_t len, uintptr_t * res)
{
  int D.24272;
  int iftmp.143;
  unsigned int D.24276;
  unsigned int D.24278;
  unsigned int D.24280;
  _Bool D.24282;
  long int D.24283;
  long int D.24284;
  gboolean D.24287;
  _Bool D.24288;
  long int D.24289;
  long int D.24290;
  uintptr_t byte_len;

  D.24272 = mono_array_element_size (class);
  byte_len = (uintptr_t) D.24272;
  D.24276 = (unsigned int) byte_len;
  if (D.24276 != 0) goto <D.24277>; else goto <D.24274>;
  <D.24277>:
  D.24278 = (unsigned int) len;
  if (D.24278 != 0) goto <D.24279>; else goto <D.24274>;
  <D.24279>:
  D.24278 = (unsigned int) len;
  D.24276 = (unsigned int) byte_len;
  D.24280 = 4294967295 / D.24276;
  if (D.24278 > D.24280) goto <D.24281>; else goto <D.24274>;
  <D.24281>:
  iftmp.143 = 1;
  goto <D.24275>;
  <D.24274>:
  iftmp.143 = 0;
  <D.24275>:
  D.24282 = iftmp.143 != 0;
  D.24283 = (long int) D.24282;
  D.24284 = __builtin_expect (D.24283, 0);
  if (D.24284 != 0) goto <D.24285>; else goto <D.24286>;
  <D.24285>:
  D.24287 = 0;
  return D.24287;
  <D.24286>:
  byte_len = byte_len * len;
  D.24276 = (unsigned int) byte_len;
  D.24288 = D.24276 > 4294967263;
  D.24289 = (long int) D.24288;
  D.24290 = __builtin_expect (D.24289, 0);
  if (D.24290 != 0) goto <D.24291>; else goto <D.24292>;
  <D.24291>:
  D.24287 = 0;
  return D.24287;
  <D.24292>:
  byte_len = byte_len + 32;
  *res = byte_len;
  D.24287 = 1;
  return D.24287;
}


mono_array_new_full (struct MonoDomain * domain, struct MonoClass * array_class, uintptr_t * lengths, intptr_t * lower_bounds)
{
  unsigned char D.24294;
  unsigned char D.24295;
  unsigned char D.24300;
  unsigned char D.24302;
  long int D.24305;
  long unsigned int D.24308;
  long unsigned int D.24309;
  long unsigned int D.24310;
  uintptr_t * D.24311;
  long unsigned int D.24312;
  int iftmp.144;
  unsigned int D.24318;
  unsigned int D.24320;
  unsigned int D.24322;
  _Bool D.24324;
  long int D.24325;
  long int D.24326;
  int D.24329;
  int D.24330;
  long unsigned int byte_len.145;
  unsigned int D.24336;
  _Bool D.24337;
  long int D.24338;
  long int D.24339;
  long unsigned int D.24342;
  long unsigned int byte_len.146;
  unsigned int D.24344;
  unsigned int D.24345;
  _Bool D.24346;
  long int D.24347;
  long int D.24348;
  long unsigned int byte_len.147;
  long unsigned int D.24355;
  long unsigned int D.24356;
  struct MonoArrayBounds * D.24359;
  unsigned int D.24360;
  intptr_t * D.24363;
  long int D.24364;
  int D.24365;
  int profile_allocs.148;
  _Bool D.24367;
  long int D.24368;
  long int D.24369;
  struct MonoArray * D.24372;
  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.24294 = BIT_FIELD_REF <*array_class, 8, 256>;
      D.24295 = D.24294 & 1;
      if (D.24295 == 0) goto <D.24296>; else goto <D.24297>;
      <D.24296>:
      mono_class_init (array_class);
      <D.24297>:
      len = 1;
      D.24300 = array_class->rank;
      if (D.24300 == 1) goto <D.24301>; else goto <D.24298>;
      <D.24301>:
      D.24302 = array_class->byval_arg.type;
      if (D.24302 == 29) goto <D.24299>; else goto <D.24303>;
      <D.24303>:
      if (lower_bounds != 0B) goto <D.24304>; else goto <D.24298>;
      <D.24304>:
      D.24305 = *lower_bounds;
      if (D.24305 == 0) goto <D.24299>; else goto <D.24298>;
      <D.24299>:
      len = *lengths;
      if (len > 2147483647) goto <D.24306>; else goto <D.24307>;
      <D.24306>:
      arith_overflow ();
      <D.24307>:
      bounds_size = 0;
      goto <D.20290>;
      <D.24298>:
      D.24300 = array_class->rank;
      D.24308 = (long unsigned int) D.24300;
      bounds_size = D.24308 * 8;
      i = 0;
      goto <D.20289>;
      <D.20288>:
      D.24309 = (long unsigned int) i;
      D.24310 = D.24309 * 8;
      D.24311 = lengths + D.24310;
      D.24312 = *D.24311;
      if (D.24312 > 2147483647) goto <D.24313>; else goto <D.24314>;
      <D.24313>:
      arith_overflow ();
      <D.24314>:
      D.24318 = (unsigned int) len;
      if (D.24318 != 0) goto <D.24319>; else goto <D.24316>;
      <D.24319>:
      D.24309 = (long unsigned int) i;
      D.24310 = D.24309 * 8;
      D.24311 = lengths + D.24310;
      D.24312 = *D.24311;
      D.24320 = (unsigned int) D.24312;
      if (D.24320 != 0) goto <D.24321>; else goto <D.24316>;
      <D.24321>:
      D.24309 = (long unsigned int) i;
      D.24310 = D.24309 * 8;
      D.24311 = lengths + D.24310;
      D.24312 = *D.24311;
      D.24320 = (unsigned int) D.24312;
      D.24318 = (unsigned int) len;
      D.24322 = 4294967295 / D.24318;
      if (D.24320 > D.24322) goto <D.24323>; else goto <D.24316>;
      <D.24323>:
      iftmp.144 = 1;
      goto <D.24317>;
      <D.24316>:
      iftmp.144 = 0;
      <D.24317>:
      D.24324 = iftmp.144 != 0;
      D.24325 = (long int) D.24324;
      D.24326 = __builtin_expect (D.24325, 0);
      if (D.24326 != 0) goto <D.24327>; else goto <D.24328>;
      <D.24327>:
      mono_gc_out_of_memory (4294967295);
      <D.24328>:
      D.24309 = (long unsigned int) i;
      D.24310 = D.24309 * 8;
      D.24311 = lengths + D.24310;
      D.24312 = *D.24311;
      len = D.24312 * len;
      i = i + 1;
      <D.20289>:
      D.24300 = array_class->rank;
      D.24329 = (int) D.24300;
      if (D.24329 > i) goto <D.20288>; else goto <D.20290>;
      <D.20290>:
      D.24330 = mono_array_calc_byte_len (array_class, len, &byte_len);
      if (D.24330 == 0) goto <D.24331>; else goto <D.24332>;
      <D.24331>:
      mono_gc_out_of_memory (4294967295);
      <D.24332>:
      if (bounds_size != 0) goto <D.24333>; else goto <D.24334>;
      <D.24333>:
      byte_len.145 = byte_len;
      D.24336 = (unsigned int) byte_len.145;
      D.24337 = D.24336 > 4294967292;
      D.24338 = (long int) D.24337;
      D.24339 = __builtin_expect (D.24338, 0);
      if (D.24339 != 0) goto <D.24340>; else goto <D.24341>;
      <D.24340>:
      mono_gc_out_of_memory (4294967295);
      <D.24341>:
      byte_len.145 = byte_len;
      D.24342 = byte_len.145 + 3;
      byte_len.146 = D.24342 & 18446744073709551612;
      byte_len = byte_len.146;
      D.24344 = (unsigned int) bounds_size;
      D.24345 = ~D.24344;
      byte_len.145 = byte_len;
      D.24336 = (unsigned int) byte_len.145;
      D.24346 = D.24345 < D.24336;
      D.24347 = (long int) D.24346;
      D.24348 = __builtin_expect (D.24347, 0);
      if (D.24348 != 0) goto <D.24349>; else goto <D.24350>;
      <D.24349>:
      mono_gc_out_of_memory (4294967295);
      <D.24350>:
      byte_len.145 = byte_len;
      byte_len.147 = byte_len.145 + bounds_size;
      byte_len = byte_len.147;
      <D.24334>:
      vtable = mono_class_vtable_full (domain, array_class, 1);
      if (bounds_size != 0) goto <D.24352>; else goto <D.24353>;
      <D.24352>:
      byte_len.145 = byte_len;
      o = mono_gc_alloc_array (vtable, byte_len.145, len, bounds_size);
      goto <D.24354>;
      <D.24353>:
      byte_len.145 = byte_len;
      o = mono_gc_alloc_vector (vtable, byte_len.145, len);
      <D.24354>:
      array = o;
      D.24355 = mono_stats.new_object_count;
      D.24356 = D.24355 + 1;
      mono_stats.new_object_count = D.24356;
      bounds = array->bounds;
      if (bounds_size != 0) goto <D.24357>; else goto <D.24358>;
      <D.24357>:
      i = 0;
      goto <D.20292>;
      <D.20291>:
      D.24309 = (long unsigned int) i;
      D.24310 = D.24309 * 8;
      D.24359 = bounds + D.24310;
      D.24309 = (long unsigned int) i;
      D.24310 = D.24309 * 8;
      D.24311 = lengths + D.24310;
      D.24312 = *D.24311;
      D.24360 = (unsigned int) D.24312;
      D.24359->length = D.24360;
      if (lower_bounds != 0B) goto <D.24361>; else goto <D.24362>;
      <D.24361>:
      D.24309 = (long unsigned int) i;
      D.24310 = D.24309 * 8;
      D.24359 = bounds + D.24310;
      D.24309 = (long unsigned int) i;
      D.24310 = D.24309 * 8;
      D.24363 = lower_bounds + D.24310;
      D.24364 = *D.24363;
      D.24365 = (int) D.24364;
      D.24359->lower_bound = D.24365;
      <D.24362>:
      i = i + 1;
      <D.20292>:
      D.24300 = array_class->rank;
      D.24329 = (int) D.24300;
      if (D.24329 > i) goto <D.20291>; else goto <D.20293>;
      <D.20293>:
      <D.24358>:
      profile_allocs.148 = profile_allocs;
      D.24367 = profile_allocs.148 != 0;
      D.24368 = (long int) D.24367;
      D.24369 = __builtin_expect (D.24368, 0);
      if (D.24369 != 0) goto <D.24370>; else goto <D.24371>;
      <D.24370>:
      mono_profiler_allocation (o, array_class);
      <D.24371>:
      D.24372 = array;
      return D.24372;
    }
  finally
    {
      byte_len = {CLOBBER};
    }
}


arith_overflow ()
{
  struct MonoException * D.24375;

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


mono_array_new (struct MonoDomain * domain, struct MonoClass * eclass, uintptr_t n)
{
  _Bool D.24376;
  long int D.24377;
  long int D.24378;
  struct MonoArray * D.24381;
  struct MonoVTable * D.24382;
  struct MonoClass * ac;

  ac = mono_array_class_get (eclass, 1);
  D.24376 = ac == 0B;
  D.24377 = (long int) D.24376;
  D.24378 = __builtin_expect (D.24377, 0);
  if (D.24378 != 0) goto <D.24379>; else goto <D.24380>;
  <D.24379>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 4869, "ac");
  <D.24380>:
  D.24382 = mono_class_vtable_full (domain, ac, 1);
  D.24381 = mono_array_new_specific (D.24382, n);
  return D.24381;
}


mono_array_new_specific (struct MonoVTable * vtable, uintptr_t n)
{
  _Bool D.24384;
  long int D.24385;
  long int D.24386;
  struct MonoArray * D.24389;
  struct MonoClass * D.24390;
  int D.24391;
  long unsigned int byte_len.149;
  long unsigned int D.24395;
  long unsigned int D.24396;
  int profile_allocs.150;
  _Bool D.24398;
  long int D.24399;
  long int D.24400;
  struct MonoObject * o;
  struct MonoArray * ao;
  uintptr_t byte_len;

  try
    {
      D.24384 = n > 2147483647;
      D.24385 = (long int) D.24384;
      D.24386 = __builtin_expect (D.24385, 0);
      if (D.24386 != 0) goto <D.24387>; else goto <D.24388>;
      <D.24387>:
      arith_overflow ();
      D.24389 = 0B;
      return D.24389;
      <D.24388>:
      D.24390 = vtable->klass;
      D.24391 = mono_array_calc_byte_len (D.24390, n, &byte_len);
      if (D.24391 == 0) goto <D.24392>; else goto <D.24393>;
      <D.24392>:
      mono_gc_out_of_memory (4294967295);
      D.24389 = 0B;
      return D.24389;
      <D.24393>:
      byte_len.149 = byte_len;
      o = mono_gc_alloc_vector (vtable, byte_len.149, n);
      ao = o;
      D.24395 = mono_stats.new_object_count;
      D.24396 = D.24395 + 1;
      mono_stats.new_object_count = D.24396;
      profile_allocs.150 = profile_allocs;
      D.24398 = profile_allocs.150 != 0;
      D.24399 = (long int) D.24398;
      D.24400 = __builtin_expect (D.24399, 0);
      if (D.24400 != 0) goto <D.24401>; else goto <D.24402>;
      <D.24401>:
      D.24390 = vtable->klass;
      mono_profiler_allocation (o, D.24390);
      <D.24402>:
      D.24389 = ao;
      return D.24389;
    }
  finally
    {
      byte_len = {CLOBBER};
    }
}


mono_string_new_utf16 (struct MonoDomain * domain, const guint16 * text, gint32 len)
{
  _Bool D.24405;
  long int D.24406;
  long int D.24407;
  int D.24410;
  long unsigned int D.24411;
  mono_unichar2 * D.24412;
  struct MonoString * D.24413;
  struct MonoString * s;

  s = mono_string_new_size (domain, len);
  D.24405 = s == 0B;
  D.24406 = (long int) D.24405;
  D.24407 = __builtin_expect (D.24406, 0);
  if (D.24407 != 0) goto <D.24408>; else goto <D.24409>;
  <D.24408>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 4941, "s != NULL");
  <D.24409>:
  D.24410 = len * 2;
  D.24411 = (long unsigned int) D.24410;
  D.24412 = mono_string_chars (s);
  memcpy (D.24412, text, D.24411);
  D.24413 = s;
  return D.24413;
}


mono_string_new_size (struct MonoDomain * domain, gint32 len)
{
  int D.24415;
  int D.24416;
  long unsigned int D.24417;
  long unsigned int D.24418;
  struct MonoClass * D.24421;
  _Bool D.24422;
  long int D.24423;
  long int D.24424;
  int profile_allocs.151;
  _Bool D.24428;
  long int D.24429;
  long int D.24430;
  struct MonoString * D.24433;
  struct MonoString * s;
  struct MonoVTable * vtable;
  size_t size;

  D.24415 = len + 1;
  D.24416 = D.24415 * 2;
  D.24417 = (long unsigned int) D.24416;
  size = D.24417 + 24;
  D.24418 = (long unsigned int) len;
  if (D.24418 > size) goto <D.24419>; else goto <D.24420>;
  <D.24419>:
  mono_gc_out_of_memory (18446744073709551615);
  <D.24420>:
  D.24421 = mono_defaults.string_class;
  vtable = mono_class_vtable (domain, D.24421);
  D.24422 = vtable == 0B;
  D.24423 = (long int) D.24422;
  D.24424 = __builtin_expect (D.24423, 0);
  if (D.24424 != 0) goto <D.24425>; else goto <D.24426>;
  <D.24425>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 4967, "vtable");
  <D.24426>:
  s = mono_gc_alloc_string (vtable, size, len);
  profile_allocs.151 = profile_allocs;
  D.24428 = profile_allocs.151 != 0;
  D.24429 = (long int) D.24428;
  D.24430 = __builtin_expect (D.24429, 0);
  if (D.24430 != 0) goto <D.24431>; else goto <D.24432>;
  <D.24431>:
  D.24421 = mono_defaults.string_class;
  mono_profiler_allocation (s, D.24421);
  <D.24432>:
  D.24433 = s;
  return D.24433;
}


mono_string_new_len (struct MonoDomain * domain, const char * text, guint length)
{
  long int D.24435;
  struct GError * error.152;
  long int items_written.153;
  int D.24440;
  struct MonoString * D.24442;
  struct GError * error;
  struct MonoString * o;
  guint16 * ut;
  glong items_written;

  try
    {
      error = 0B;
      o = 0B;
      D.24435 = (long int) length;
      ut = eg_utf8_to_utf16_with_nuls (text, D.24435, 0B, &items_written, &error);
      error.152 = error;
      if (error.152 == 0B) goto <D.24437>; else goto <D.24438>;
      <D.24437>:
      items_written.153 = items_written;
      D.24440 = (int) items_written.153;
      o = mono_string_new_utf16 (domain, ut, D.24440);
      goto <D.24441>;
      <D.24438>:
      error.152 = error;
      monoeg_g_error_free (error.152);
      <D.24441>:
      monoeg_g_free (ut);
      D.24442 = o;
      return D.24442;
    }
  finally
    {
      error = {CLOBBER};
      items_written = {CLOBBER};
    }
}


mono_string_new (struct MonoDomain * domain, const char * text)
{
  long unsigned int D.24445;
  long int D.24446;
  struct GError * error.154;
  long int items_written.155;
  int D.24451;
  struct MonoString * D.24453;
  struct GError * error;
  struct MonoString * o;
  guint16 * ut;
  glong items_written;
  int l;

  try
    {
      error = 0B;
      o = 0B;
      D.24445 = strlen (text);
      l = (int) D.24445;
      D.24446 = (long int) l;
      ut = monoeg_g_utf8_to_utf16 (text, D.24446, 0B, &items_written, &error);
      error.154 = error;
      if (error.154 == 0B) goto <D.24448>; else goto <D.24449>;
      <D.24448>:
      items_written.155 = items_written;
      D.24451 = (int) items_written.155;
      o = mono_string_new_utf16 (domain, ut, D.24451);
      goto <D.24452>;
      <D.24449>:
      error.154 = error;
      monoeg_g_error_free (error.154);
      <D.24452>:
      monoeg_g_free (ut);
      D.24453 = o;
      return D.24453;
    }
  finally
    {
      error = {CLOBBER};
      items_written = {CLOBBER};
    }
}


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

  domain = mono_domain_get ();
  if (text != 0B) goto <D.24456>; else goto <D.24457>;
  <D.24456>:
  D.24458 = mono_string_new (domain, text);
  return D.24458;
  <D.24457>:
  D.24458 = 0B;
  return D.24458;
}


mono_value_box (struct MonoDomain * domain, struct MonoClass * class, void * value)
{
  unsigned char D.24460;
  unsigned char D.24461;
  _Bool D.24462;
  long int D.24463;
  long int D.24464;
  int D.24467;
  struct MonoObject * D.24470;
  int profile_allocs.156;
  _Bool D.24474;
  long int D.24475;
  long int D.24476;
  unsigned int size.157;
  unsigned int D.24480;
  int D.24481;
  _Bool D.24482;
  long int D.24483;
  long int D.24484;
  void * D.24487;
  unsigned char D.24488;
  unsigned char D.24489;
  struct MonoObject * res;
  int size;
  struct MonoVTable * vtable;

  D.24460 = BIT_FIELD_REF <*class, 8, 256>;
  D.24461 = D.24460 & 8;
  D.24462 = D.24461 == 0;
  D.24463 = (long int) D.24462;
  D.24464 = __builtin_expect (D.24463, 0);
  if (D.24464 != 0) goto <D.24465>; else goto <D.24466>;
  <D.24465>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 5092, "class->valuetype");
  <D.24466>:
  D.24467 = mono_class_is_nullable (class);
  if (D.24467 != 0) goto <D.24468>; else goto <D.24469>;
  <D.24468>:
  D.24470 = mono_nullable_box (value, class);
  return D.24470;
  <D.24469>:
  vtable = mono_class_vtable (domain, class);
  if (vtable == 0B) goto <D.24471>; else goto <D.24472>;
  <D.24471>:
  D.24470 = 0B;
  return D.24470;
  <D.24472>:
  size = mono_class_instance_size (class);
  res = mono_object_new_alloc_specific (vtable);
  profile_allocs.156 = profile_allocs;
  D.24474 = profile_allocs.156 != 0;
  D.24475 = (long int) D.24474;
  D.24476 = __builtin_expect (D.24475, 0);
  if (D.24476 != 0) goto <D.24477>; else goto <D.24478>;
  <D.24477>:
  mono_profiler_allocation (res, class);
  <D.24478>:
  size.157 = (unsigned int) size;
  D.24480 = size.157 + 4294967280;
  size = (int) D.24480;
  D.24481 = mono_class_value_size (class, 0B);
  D.24482 = D.24481 != size;
  D.24483 = (long int) D.24482;
  D.24484 = __builtin_expect (D.24483, 0);
  if (D.24484 != 0) goto <D.24485>; else goto <D.24486>;
  <D.24485>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 5107, "size == mono_class_value_size (class, NULL)");
  <D.24486>:
  D.24487 = res + 16;
  mono_gc_wbarrier_value_copy (D.24487, value, 1, class);
  D.24488 = BIT_FIELD_REF <*class, 8, 272>;
  D.24489 = D.24488 & 32;
  if (D.24489 != 0) goto <D.24490>; else goto <D.24491>;
  <D.24490>:
  mono_object_register_finalizer (res);
  <D.24491>:
  D.24470 = res;
  return D.24470;
}


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.24493;
  struct MonoClass * D.24494;
  double[0:] * D.24495;
  int D.24496;
  sizetype D.24497;
  struct MonoVTable * D.24498;
  struct MonoClass * D.24499;
  struct MonoClass * D.24500;
  int D.24501;
  _Bool D.24502;
  long int D.24503;
  long int D.24504;
  int size;
  char * d;

  D.24493 = dest->obj.vtable;
  D.24494 = D.24493->klass;
  size = mono_array_element_size (D.24494);
  D.24495 = &dest->vector;
  D.24496 = size * dest_idx;
  D.24497 = (sizetype) D.24496;
  d = D.24495 + D.24497;
  D.24498 = MEM[(struct MonoObject *)dest].vtable;
  D.24499 = D.24498->klass;
  D.24500 = D.24499->element_class;
  D.24501 = mono_class_value_size (D.24500, 0B);
  D.24502 = D.24501 != size;
  D.24503 = (long int) D.24502;
  D.24504 = __builtin_expect (D.24503, 0);
  if (D.24504 != 0) goto <D.24505>; else goto <D.24506>;
  <D.24505>:
  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.24506>:
  D.24498 = MEM[(struct MonoObject *)dest].vtable;
  D.24499 = D.24498->klass;
  D.24500 = D.24499->element_class;
  mono_gc_wbarrier_value_copy (d, src, count, D.24500);
}


mono_object_get_domain (struct MonoObject * obj)
{
  struct MonoDomain * D.24507;
  struct MonoVTable * D.24508;

  D.24508 = obj->vtable;
  D.24507 = D.24508->domain;
  return D.24507;
}


mono_object_get_class (struct MonoObject * obj)
{
  struct MonoClass * D.24510;
  struct MonoVTable * D.24511;

  D.24511 = obj->vtable;
  D.24510 = D.24511->klass;
  return D.24510;
}


mono_object_get_size (struct MonoObject * o)
{
  struct MonoVTable * D.24513;
  struct MonoClass * D.24514;
  unsigned int D.24517;
  int D.24518;
  int D.24519;
  unsigned int D.24520;
  unsigned char D.24521;
  int D.24524;
  long unsigned int D.24525;
  long unsigned int D.24526;
  long unsigned int D.24527;
  struct MonoArrayBounds * D.24528;
  long unsigned int D.24531;
  long unsigned int D.24532;
  int D.24533;
  struct MonoClass * klass;

  D.24513 = o->vtable;
  klass = D.24513->klass;
  D.24514 = mono_defaults.string_class;
  if (D.24514 == klass) goto <D.24515>; else goto <D.24516>;
  <D.24515>:
  D.24518 = mono_string_length (o);
  D.24519 = D.24518 * 2;
  D.24520 = (unsigned int) D.24519;
  D.24517 = D.24520 + 26;
  return D.24517;
  <D.24516>:
  D.24513 = o->vtable;
  D.24521 = D.24513->rank;
  if (D.24521 != 0) goto <D.24522>; else goto <D.24523>;
  <D.24522>:
  {
    struct MonoArray * array;
    size_t size;

    array = o;
    D.24524 = mono_array_element_size (klass);
    D.24525 = (long unsigned int) D.24524;
    D.24526 = mono_array_length (array);
    D.24527 = D.24525 * D.24526;
    size = D.24527 + 32;
    D.24528 = array->bounds;
    if (D.24528 != 0B) goto <D.24529>; else goto <D.24530>;
    <D.24529>:
    size = size + 3;
    size = size & 18446744073709551612;
    D.24513 = o->vtable;
    D.24521 = D.24513->rank;
    D.24531 = (long unsigned int) D.24521;
    D.24532 = D.24531 * 8;
    size = D.24532 + size;
    <D.24530>:
    D.24517 = (unsigned int) size;
    return D.24517;
  }
  <D.24523>:
  D.24533 = mono_class_instance_size (klass);
  D.24517 = (unsigned int) D.24533;
  return D.24517;
}


mono_object_unbox (struct MonoObject * obj)
{
  struct MonoVTable * D.24535;
  struct MonoClass * D.24536;
  unsigned char D.24537;
  unsigned char D.24538;
  _Bool D.24539;
  long int D.24540;
  long int D.24541;
  void * D.24544;

  D.24535 = obj->vtable;
  D.24536 = D.24535->klass;
  D.24537 = BIT_FIELD_REF <*D.24536, 8, 256>;
  D.24538 = D.24537 & 8;
  D.24539 = D.24538 == 0;
  D.24540 = (long int) D.24539;
  D.24541 = __builtin_expect (D.24540, 0);
  if (D.24541 != 0) goto <D.24542>; else goto <D.24543>;
  <D.24542>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 5233, "obj->vtable->klass->valuetype");
  <D.24543>:
  D.24544 = obj + 16;
  return D.24544;
}


mono_object_isinst (struct MonoObject * obj, struct MonoClass * klass)
{
  unsigned char D.24546;
  unsigned char D.24547;
  unsigned char D.24552;
  unsigned char D.24553;
  unsigned int D.24555;
  unsigned int D.24556;
  struct MonoObject * D.24557;
  struct MonoObject * iftmp.158;
  struct MonoVTable * D.24561;
  struct MonoClass * D.24562;
  int D.24563;

  D.24546 = BIT_FIELD_REF <*klass, 8, 256>;
  D.24547 = D.24546 & 1;
  if (D.24547 == 0) goto <D.24548>; else goto <D.24549>;
  <D.24548>:
  mono_class_init (klass);
  <D.24549>:
  D.24552 = BIT_FIELD_REF <*klass, 8, 272>;
  D.24553 = D.24552 & 64;
  if (D.24553 != 0) goto <D.24550>; else goto <D.24554>;
  <D.24554>:
  D.24555 = klass->flags;
  D.24556 = D.24555 & 32;
  if (D.24556 != 0) goto <D.24550>; else goto <D.24551>;
  <D.24550>:
  D.24557 = mono_object_isinst_mbyref (obj, klass);
  return D.24557;
  <D.24551>:
  if (obj == 0B) goto <D.24558>; else goto <D.24559>;
  <D.24558>:
  D.24557 = 0B;
  return D.24557;
  <D.24559>:
  D.24561 = obj->vtable;
  D.24562 = D.24561->klass;
  D.24563 = mono_class_is_assignable_from (klass, D.24562);
  if (D.24563 != 0) goto <D.24564>; else goto <D.24565>;
  <D.24564>:
  iftmp.158 = obj;
  goto <D.24566>;
  <D.24565>:
  iftmp.158 = 0B;
  <D.24566>:
  D.24557 = iftmp.158;
  return D.24557;
}


mono_object_isinst_mbyref (struct MonoObject * obj, struct MonoClass * klass)
{
  struct MonoObject * D.24570;
  unsigned int D.24571;
  unsigned int D.24572;
  short unsigned int D.24575;
  short unsigned int D.24576;
  guint8 * D.24579;
  short unsigned int D.24580;
  sizetype D.24581;
  guint8 * D.24582;
  unsigned char D.24583;
  int D.24584;
  int D.24585;
  int D.24586;
  int D.24587;
  int D.24588;
  int D.24591;
  struct MonoVTable * D.24594;
  struct MonoClass * D.24595;
  int D.24596;
  struct MonoClass * D.24600;
  struct MonoRemoteClass * D.24603;
  short unsigned int D.24604;
  short unsigned int D.24605;
  struct MonoClass * * D.24608;
  long unsigned int D.24609;
  long unsigned int D.24610;
  sizetype D.24611;
  struct MonoClass * * D.24612;
  struct MonoClass * D.24613;
  struct MonoClass * D.24616;
  unsigned char D.24619;
  _Bool D.24622;
  long int D.24623;
  long int D.24624;
  struct MonoType * D.24627;
  struct MonoReflectionType * D.24628;
  void * D.24629;
  unsigned char D.24630;
  struct MonoVTable * vt;

  if (obj == 0B) goto <D.24568>; else goto <D.24569>;
  <D.24568>:
  D.24570 = 0B;
  return D.24570;
  <D.24569>:
  vt = obj->vtable;
  D.24571 = klass->flags;
  D.24572 = D.24571 & 32;
  if (D.24572 != 0) goto <D.24573>; else goto <D.24574>;
  <D.24573>:
  D.24575 = klass->interface_id;
  D.24576 = vt->max_interface_id;
  if (D.24575 <= D.24576) goto <D.24577>; else goto <D.24578>;
  <D.24577>:
  D.24579 = vt->interface_bitmap;
  D.24575 = klass->interface_id;
  D.24580 = D.24575 >> 3;
  D.24581 = (sizetype) D.24580;
  D.24582 = D.24579 + D.24581;
  D.24583 = *D.24582;
  D.24584 = (int) D.24583;
  D.24575 = klass->interface_id;
  D.24585 = (int) D.24575;
  D.24586 = D.24585 & 7;
  D.24587 = D.24584 >> D.24586;
  D.24588 = D.24587 & 1;
  if (D.24588 != 0) goto <D.24589>; else goto <D.24590>;
  <D.24589>:
  D.24570 = obj;
  return D.24570;
  <D.24590>:
  <D.24578>:
  D.24591 = mono_class_has_variant_generic_params (klass);
  if (D.24591 != 0) goto <D.24592>; else goto <D.24593>;
  <D.24592>:
  D.24594 = obj->vtable;
  D.24595 = D.24594->klass;
  D.24596 = mono_class_is_assignable_from (klass, D.24595);
  if (D.24596 != 0) goto <D.24597>; else goto <D.24598>;
  <D.24597>:
  D.24570 = obj;
  return D.24570;
  <D.24598>:
  <D.24593>:
  goto <D.24599>;
  <D.24574>:
  {
    struct MonoClass * oklass;

    oklass = vt->klass;
    D.24600 = mono_defaults.transparent_proxy_class;
    if (D.24600 == oklass) goto <D.24601>; else goto <D.24602>;
    <D.24601>:
    D.24603 = MEM[(struct MonoTransparentProxy *)obj].remote_class;
    oklass = D.24603->proxy_class;
    <D.24602>:
    mono_class_setup_supertypes (klass);
    D.24604 = oklass->idepth;
    D.24605 = klass->idepth;
    if (D.24604 >= D.24605) goto <D.24606>; else goto <D.24607>;
    <D.24606>:
    D.24608 = oklass->supertypes;
    D.24605 = klass->idepth;
    D.24609 = (long unsigned int) D.24605;
    D.24610 = D.24609 * 8;
    D.24611 = D.24610 + 18446744073709551608;
    D.24612 = D.24608 + D.24611;
    D.24613 = *D.24612;
    if (D.24613 == klass) goto <D.24614>; else goto <D.24615>;
    <D.24614>:
    D.24570 = obj;
    return D.24570;
    <D.24615>:
    <D.24607>:
  }
  <D.24599>:
  D.24616 = vt->klass;
  D.24600 = mono_defaults.transparent_proxy_class;
  if (D.24616 == D.24600) goto <D.24617>; else goto <D.24618>;
  <D.24617>:
  D.24619 = MEM[(struct MonoTransparentProxy *)obj].custom_type_info;
  if (D.24619 != 0) goto <D.24620>; else goto <D.24621>;
  <D.24620>:
  {
    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.24622 = im == 0B;
        D.24623 = (long int) D.24622;
        D.24624 = __builtin_expect (D.24623, 0);
        if (D.24624 != 0) goto <D.24625>; else goto <D.24626>;
        <D.24625>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 5298, "im");
        <D.24626>:
        D.24627 = &klass->byval_arg;
        D.24628 = mono_type_get_object (domain, D.24627);
        pa[0] = D.24628;
        pa[1] = obj;
        res = mono_runtime_invoke (im, rp, &pa, 0B);
        D.24629 = mono_object_unbox (res);
        D.24630 = MEM[(MonoBoolean *)D.24629];
        if (D.24630 != 0) goto <D.24631>; else goto <D.24632>;
        <D.24631>:
        mono_upgrade_remote_class (domain, obj, klass);
        D.24570 = obj;
        return D.24570;
        <D.24632>:
      }
    finally
      {
        pa = {CLOBBER};
      }
  }
  <D.24621>:
  <D.24618>:
  D.24570 = 0B;
  return D.24570;
}


mono_object_castclass_mbyref (struct MonoObject * obj, struct MonoClass * klass)
{
  struct MonoObject * D.24638;
  struct MonoObject * D.24639;
  struct MonoImage * D.24642;
  struct MonoException * D.24643;

  if (obj == 0B) goto <D.24636>; else goto <D.24637>;
  <D.24636>:
  D.24638 = 0B;
  return D.24638;
  <D.24637>:
  D.24639 = mono_object_isinst_mbyref (obj, klass);
  if (D.24639 != 0B) goto <D.24640>; else goto <D.24641>;
  <D.24640>:
  D.24638 = obj;
  return D.24638;
  <D.24641>:
  D.24642 = mono_defaults.corlib;
  D.24643 = mono_exception_from_name (D.24642, "System", "InvalidCastException");
  mono_raise_exception (D.24643);
  D.24638 = 0B;
  return D.24638;
}


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

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


mono_string_is_interned_lookup (struct MonoString * str, int insert)
{
  struct MonoVTable * D.24647;
  _Bool D.24650;
  long int D.24651;
  long int D.24652;
  _Bool D.24659;
  long int D.24660;
  long int D.24661;
  struct MonoString * D.24664;
  _Bool D.24671;
  long int D.24672;
  long int D.24673;
  struct MonoString * D.24676;
  _Bool D.24681;
  long int D.24682;
  long int D.24683;
  _Bool D.24688;
  long int D.24689;
  long int D.24690;
  struct MonoGHashTable * ldstr_table;
  struct MonoString * res;
  struct MonoDomain * domain;

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

    ret = pthread_mutex_lock (&ldstr_section.mutex);
    if (ret != 0) goto <D.24648>; else goto <D.24649>;
    <D.24648>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
    <D.24649>:
    D.24650 = ret != 0;
    D.24651 = (long int) D.24650;
    D.24652 = __builtin_expect (D.24651, 0);
    if (D.24652 != 0) goto <D.24653>; else goto <D.24654>;
    <D.24653>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 5378, "ret == 0");
    <D.24654>:
  }
  res = mono_g_hash_table_lookup (ldstr_table, str);
  if (res != 0B) goto <D.24655>; else goto <D.24656>;
  <D.24655>:
  {
    int ret;

    ret = pthread_mutex_unlock (&ldstr_section.mutex);
    if (ret != 0) goto <D.24657>; else goto <D.24658>;
    <D.24657>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.24658>:
    D.24659 = ret != 0;
    D.24660 = (long int) D.24659;
    D.24661 = __builtin_expect (D.24660, 0);
    if (D.24661 != 0) goto <D.24662>; else goto <D.24663>;
    <D.24662>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 5380, "ret == 0");
    <D.24663>:
  }
  D.24664 = res;
  return D.24664;
  <D.24656>:
  if (insert != 0) goto <D.24665>; else goto <D.24666>;
  <D.24665>:
  str = mono_string_get_pinned (str);
  if (str != 0B) goto <D.24667>; else goto <D.24668>;
  <D.24667>:
  mono_g_hash_table_insert (ldstr_table, str, str);
  <D.24668>:
  {
    int ret;

    ret = pthread_mutex_unlock (&ldstr_section.mutex);
    if (ret != 0) goto <D.24669>; else goto <D.24670>;
    <D.24669>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.24670>:
    D.24671 = ret != 0;
    D.24672 = (long int) D.24671;
    D.24673 = __builtin_expect (D.24672, 0);
    if (D.24673 != 0) goto <D.24674>; else goto <D.24675>;
    <D.24674>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 5387, "ret == 0");
    <D.24675>:
  }
  D.24664 = str;
  return D.24664;
  <D.24666>:
  {
    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.24676 = ldstr_info.res;
        if (D.24676 != 0B) goto <D.24677>; else goto <D.24678>;
        <D.24677>:
        mono_g_hash_table_insert (ldstr_table, str, str);
        {
          int ret;

          ret = pthread_mutex_unlock (&ldstr_section.mutex);
          if (ret != 0) goto <D.24679>; else goto <D.24680>;
          <D.24679>:
          monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
          <D.24680>:
          D.24681 = ret != 0;
          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", 5402, "ret == 0");
          <D.24685>:
        }
        D.24664 = str;
        return D.24664;
        <D.24678>:
      }
    finally
      {
        ldstr_info = {CLOBBER};
      }
  }
  {
    int ret;

    ret = pthread_mutex_unlock (&ldstr_section.mutex);
    if (ret != 0) goto <D.24686>; else goto <D.24687>;
    <D.24686>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.24687>:
    D.24688 = ret != 0;
    D.24689 = (long int) D.24688;
    D.24690 = __builtin_expect (D.24689, 0);
    if (D.24690 != 0) goto <D.24691>; else goto <D.24692>;
    <D.24691>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 5406, "ret == 0");
    <D.24692>:
  }
  D.24664 = 0B;
  return D.24664;
}


str_lookup (struct MonoDomain * domain, void * user_data)
{
  struct MonoString * D.24698;
  struct MonoDomain * D.24700;
  struct MonoString * D.24701;
  struct MonoGHashTable * D.24702;
  void * D.24703;
  struct LDStrInfo * info;

  info = user_data;
  D.24698 = info->res;
  if (D.24698 != 0B) goto <D.24696>; else goto <D.24699>;
  <D.24699>:
  D.24700 = info->orig_domain;
  if (D.24700 == domain) goto <D.24696>; else goto <D.24697>;
  <D.24696>:
  return;
  <D.24697>:
  D.24701 = info->ins;
  D.24702 = domain->ldstr_table;
  D.24703 = mono_g_hash_table_lookup (D.24702, D.24701);
  info->res = D.24703;
}


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

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


mono_ldstr (struct MonoDomain * domain, struct MonoImage * image, guint32 idx)
{
  unsigned char D.24707;
  unsigned char D.24708;
  unsigned int D.24711;
  struct MonoString * D.24712;
  int D.24713;
  const char * D.24716;

  D.24707 = BIT_FIELD_REF <*image, 8, 224>;
  D.24708 = D.24707 & 8;
  if (D.24708 != 0) goto <D.24709>; else goto <D.24710>;
  <D.24709>:
  {
    struct MonoString * str;

    D.24711 = idx | 1879048192;
    str = mono_lookup_dynamic_token (image, D.24711, 0B);
    D.24712 = str;
    return D.24712;
  }
  <D.24710>:
  D.24713 = mono_verifier_verify_string_signature (image, idx, 0B);
  if (D.24713 == 0) goto <D.24714>; else goto <D.24715>;
  <D.24714>:
  D.24712 = 0B;
  return D.24712;
  <D.24715>:
  D.24716 = mono_metadata_user_string (image, idx);
  D.24712 = mono_ldstr_metadata_sig (domain, D.24716);
  return D.24712;
}


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

  try
    {
      result = mono_string_to_utf8_checked (s, &error);
      D.24718 = mono_error_ok (&error);
      if (D.24718 == 0) goto <D.24719>; else goto <D.24720>;
      <D.24719>:
      mono_error_raise_exception (&error);
      <D.24720>:
      D.24721 = result;
      return D.24721;
    }
  finally
    {
      error = {CLOBBER};
    }
}


mono_string_to_utf8_checked (struct MonoString * s, struct MonoError * error)
{
  char * D.24726;
  int D.24727;
  long int D.24730;
  mono_unichar2 * D.24731;
  struct GError * gerror.159;
  gchar * D.24735;
  long int D.24736;
  long int written.160;
  long unsigned int D.24740;
  long unsigned int written.161;
  long int written;
  char * as;
  struct GError * gerror;

  try
    {
      written = 0;
      gerror = 0B;
      mono_error_init (error);
      if (s == 0B) goto <D.24724>; else goto <D.24725>;
      <D.24724>:
      D.24726 = 0B;
      return D.24726;
      <D.24725>:
      D.24727 = s->length;
      if (D.24727 == 0) goto <D.24728>; else goto <D.24729>;
      <D.24728>:
      D.24726 = monoeg_strdup ("");
      return D.24726;
      <D.24729>:
      D.24727 = s->length;
      D.24730 = (long int) D.24727;
      D.24731 = mono_string_chars (s);
      as = monoeg_g_utf16_to_utf8 (D.24731, D.24730, 0B, &written, &gerror);
      gerror.159 = gerror;
      if (gerror.159 != 0B) goto <D.24733>; else goto <D.24734>;
      <D.24733>:
      gerror.159 = gerror;
      D.24735 = gerror.159->message;
      mono_error_set_argument (error, "string", "%s", D.24735);
      gerror.159 = gerror;
      monoeg_g_error_free (gerror.159);
      D.24726 = 0B;
      return D.24726;
      <D.24734>:
      D.24727 = s->length;
      D.24736 = (long int) D.24727;
      written.160 = written;
      if (D.24736 > written.160) goto <D.24738>; else goto <D.24739>;
      <D.24738>:
      {
        char * as2;

        D.24727 = s->length;
        D.24740 = (long unsigned int) D.24727;
        as2 = monoeg_malloc0 (D.24740);
        written.160 = written;
        written.161 = (long unsigned int) written.160;
        memcpy (as2, as, written.161);
        monoeg_g_free (as);
        as = as2;
      }
      <D.24739>:
      D.24726 = as;
      return D.24726;
    }
  finally
    {
      written = {CLOBBER};
      gerror = {CLOBBER};
    }
}


mono_string_to_utf8_ignore (struct MonoString * s)
{
  char * D.24746;
  int D.24747;
  long int D.24750;
  mono_unichar2 * D.24751;
  long int D.24752;
  long int written.162;
  long unsigned int D.24756;
  long unsigned int written.163;
  long int written;
  char * as;

  try
    {
      written = 0;
      if (s == 0B) goto <D.24744>; else goto <D.24745>;
      <D.24744>:
      D.24746 = 0B;
      return D.24746;
      <D.24745>:
      D.24747 = s->length;
      if (D.24747 == 0) goto <D.24748>; else goto <D.24749>;
      <D.24748>:
      D.24746 = monoeg_strdup ("");
      return D.24746;
      <D.24749>:
      D.24747 = s->length;
      D.24750 = (long int) D.24747;
      D.24751 = mono_string_chars (s);
      as = monoeg_g_utf16_to_utf8 (D.24751, D.24750, 0B, &written, 0B);
      D.24747 = s->length;
      D.24752 = (long int) D.24747;
      written.162 = written;
      if (D.24752 > written.162) goto <D.24754>; else goto <D.24755>;
      <D.24754>:
      {
        char * as2;

        D.24747 = s->length;
        D.24756 = (long unsigned int) D.24747;
        as2 = monoeg_malloc0 (D.24756);
        written.162 = written;
        written.163 = (long unsigned int) written.162;
        memcpy (as2, as, written.163);
        monoeg_g_free (as);
        as = as2;
      }
      <D.24755>:
      D.24746 = as;
      return D.24746;
    }
  finally
    {
      written = {CLOBBER};
    }
}


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

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


mono_string_to_utf8_internal (struct MonoMemPool * mp, struct MonoImage * image, struct MonoString * s, gboolean ignore_error, struct MonoError * error)
{
  int D.24765;
  char * D.24768;
  _Bool D.24769;
  _Bool D.24770;
  _Bool D.24771;
  long unsigned int D.24774;
  unsigned int D.24775;
  unsigned int D.24776;
  unsigned int len.164;
  unsigned int len.165;
  long unsigned int D.24782;
  char * r;
  char * mp_s;
  int len;

  if (ignore_error != 0) goto <D.24762>; else goto <D.24763>;
  <D.24762>:
  r = mono_string_to_utf8_ignore (s);
  goto <D.24764>;
  <D.24763>:
  r = mono_string_to_utf8_checked (s, error);
  D.24765 = mono_error_ok (error);
  if (D.24765 == 0) goto <D.24766>; else goto <D.24767>;
  <D.24766>:
  D.24768 = 0B;
  return D.24768;
  <D.24767>:
  <D.24764>:
  D.24769 = mp == 0B;
  D.24770 = image == 0B;
  D.24771 = D.24769 & D.24770;
  if (D.24771 != 0) goto <D.24772>; else goto <D.24773>;
  <D.24772>:
  D.24768 = r;
  return D.24768;
  <D.24773>:
  D.24774 = strlen (r);
  D.24775 = (unsigned int) D.24774;
  D.24776 = D.24775 + 1;
  len = (int) D.24776;
  if (mp != 0B) goto <D.24777>; else goto <D.24778>;
  <D.24777>:
  len.164 = (unsigned int) len;
  mp_s = mono_mempool_alloc (mp, len.164);
  goto <D.24780>;
  <D.24778>:
  len.165 = (unsigned int) len;
  mp_s = mono_image_alloc (image, len.165);
  <D.24780>:
  D.24782 = (long unsigned int) len;
  memcpy (mp_s, r, D.24782);
  monoeg_g_free (r);
  D.24768 = mp_s;
  return D.24768;
}


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

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


mono_string_to_utf16 (struct MonoString * s)
{
  mono_unichar2 * D.24788;
  int D.24789;
  int D.24790;
  int D.24791;
  long unsigned int D.24792;
  int D.24793;
  sizetype D.24794;
  char * D.24795;
  sizetype D.24796;
  char * D.24797;
  long unsigned int D.24800;
  mono_unichar2 * D.24801;
  char * as;

  if (s == 0B) goto <D.24786>; else goto <D.24787>;
  <D.24786>:
  D.24788 = 0B;
  return D.24788;
  <D.24787>:
  D.24789 = s->length;
  D.24790 = D.24789 + 1;
  D.24791 = D.24790 * 2;
  D.24792 = (long unsigned int) D.24791;
  as = monoeg_malloc (D.24792);
  D.24789 = s->length;
  D.24793 = D.24789 * 2;
  D.24794 = (sizetype) D.24793;
  D.24795 = as + D.24794;
  *D.24795 = 0;
  D.24789 = s->length;
  D.24793 = D.24789 * 2;
  D.24794 = (sizetype) D.24793;
  D.24796 = D.24794 + 1;
  D.24797 = as + D.24796;
  *D.24797 = 0;
  D.24789 = s->length;
  if (D.24789 == 0) goto <D.24798>; else goto <D.24799>;
  <D.24798>:
  D.24788 = as;
  return D.24788;
  <D.24799>:
  D.24789 = s->length;
  D.24793 = D.24789 * 2;
  D.24800 = (long unsigned int) D.24793;
  D.24801 = mono_string_chars (s);
  memcpy (as, D.24801, D.24800);
  D.24788 = as;
  return D.24788;
}


mono_string_from_utf16 (gunichar2 * data)
{
  struct MonoString * D.24805;
  long unsigned int D.24806;
  long unsigned int D.24807;
  gunichar2 * D.24808;
  short unsigned int D.24809;
  struct MonoDomain * domain;
  int len;

  domain = mono_domain_get ();
  len = 0;
  if (data == 0B) goto <D.24803>; else goto <D.24804>;
  <D.24803>:
  D.24805 = 0B;
  return D.24805;
  <D.24804>:
  goto <D.20486>;
  <D.20485>:
  len = len + 1;
  <D.20486>:
  D.24806 = (long unsigned int) len;
  D.24807 = D.24806 * 2;
  D.24808 = data + D.24807;
  D.24809 = *D.24808;
  if (D.24809 != 0) goto <D.20485>; else goto <D.20487>;
  <D.20487>:
  D.24805 = mono_string_new_utf16 (domain, data, len);
  return D.24805;
}


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

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


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

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


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


mono_get_eh_callbacks ()
{
  struct MonoRuntimeExceptionHandlingCallbacks * D.24815;

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


mono_raise_exception (struct MonoException * ex)
{
  void (*<T2579>) (struct MonoException *) D.24817;

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


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

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


mono_wait_handle_new (struct MonoDomain * domain, void * handle)
{
  struct MonoClass * D.24819;
  struct MonoMethod * handle_set.166;
  struct MonoProperty * D.24823;
  struct MonoMethod * handle_set.167;
  struct MonoWaitHandle * D.24825;
  struct MonoWaitHandle * res;
  void * params[1];
  static struct MonoMethod * handle_set;

  try
    {
      D.24819 = mono_defaults.manualresetevent_class;
      res = mono_object_new (domain, D.24819);
      handle_set.166 = handle_set;
      if (handle_set.166 == 0B) goto <D.24821>; else goto <D.24822>;
      <D.24821>:
      D.24819 = mono_defaults.manualresetevent_class;
      D.24823 = mono_class_get_property_from_name (D.24819, "Handle");
      handle_set.167 = D.24823->set;
      handle_set = handle_set.167;
      <D.24822>:
      params[0] = &handle;
      handle_set.166 = handle_set;
      mono_runtime_invoke (handle_set.166, res, &params, 0B);
      D.24825 = res;
      return D.24825;
    }
  finally
    {
      params = {CLOBBER};
    }
}


mono_wait_handle_get_handle (struct MonoWaitHandle * handle)
{
  struct MonoClassField * f_os_handle.168;
  struct MonoClassField * f_safe_handle.169;
  struct MonoClass * D.24834;
  struct MonoClassField * f_os_handle.170;
  struct MonoClassField * f_safe_handle.171;
  void * D.24839;
  struct MonoSafeHandle * sh.172;
  static struct MonoClassField * f_os_handle;
  static struct MonoClassField * f_safe_handle;

  f_os_handle.168 = f_os_handle;
  if (f_os_handle.168 == 0B) goto <D.24829>; else goto <D.24830>;
  <D.24829>:
  f_safe_handle.169 = f_safe_handle;
  if (f_safe_handle.169 == 0B) goto <D.24832>; else goto <D.24833>;
  <D.24832>:
  D.24834 = mono_defaults.manualresetevent_class;
  f_os_handle.170 = mono_class_get_field_from_name (D.24834, "os_handle");
  f_os_handle = f_os_handle.170;
  D.24834 = mono_defaults.manualresetevent_class;
  f_safe_handle.171 = mono_class_get_field_from_name (D.24834, "safe_wait_handle");
  f_safe_handle = f_safe_handle.171;
  <D.24833>:
  <D.24830>:
  f_os_handle.168 = f_os_handle;
  if (f_os_handle.168 != 0B) goto <D.24837>; else goto <D.24838>;
  <D.24837>:
  {
    void * retval;

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

    try
      {
        f_safe_handle.169 = f_safe_handle;
        mono_field_get_value (handle, f_safe_handle.169, &sh);
        sh.172 = sh;
        D.24839 = sh.172->handle;
        return D.24839;
      }
    finally
      {
        sh = {CLOBBER};
      }
  }
}


mono_async_result_new (struct MonoDomain * domain, void * handle, struct MonoObject * state, void * data, struct MonoObject * object_data)
{
  struct MonoClass * D.24844;
  struct MonoObject * * D.24847;
  struct MonoObject * * D.24848;
  struct MonoObject * * D.24849;
  struct MonoWaitHandle * D.24852;
  struct MonoObject * * D.24853;
  struct MonoAsyncResult * D.24854;
  struct MonoAsyncResult * res;
  struct MonoObject * context;

  D.24844 = mono_defaults.asyncresult_class;
  res = mono_object_new (domain, D.24844);
  context = mono_runtime_capture_context (domain);
  if (context != 0B) goto <D.24845>; else goto <D.24846>;
  <D.24845>:
  D.24847 = &res->execution_context;
  mono_gc_wbarrier_set_field (res, D.24847, context);
  <D.24846>:
  res->data = data;
  D.24848 = &res->object_data;
  mono_gc_wbarrier_set_field (res, D.24848, object_data);
  D.24849 = &res->async_state;
  mono_gc_wbarrier_set_field (res, D.24849, state);
  if (handle != 0B) goto <D.24850>; else goto <D.24851>;
  <D.24850>:
  D.24852 = mono_wait_handle_new (domain, handle);
  D.24853 = &res->handle;
  mono_gc_wbarrier_set_field (res, D.24853, D.24852);
  <D.24851>:
  res->sync_completed = 0;
  res->completed = 0;
  D.24854 = res;
  return D.24854;
}


mono_runtime_capture_context (struct MonoDomain * domain)
{
  void * D.24858;
  void * D.24860;
  struct MonoObject * D.24863;
  void * D.24864;
  void * D.24865;
  struct MonoObject * (*RuntimeInvokeFunction) (struct MonoObject *, void * *, struct MonoObject * *, void *) runtime_invoke;

  D.24858 = domain->capture_context_runtime_invoke;
  if (D.24858 == 0B) goto <D.24856>; else goto <D.24859>;
  <D.24859>:
  D.24860 = domain->capture_context_method;
  if (D.24860 == 0B) goto <D.24856>; else goto <D.24857>;
  <D.24856>:
  {
    struct MonoMethod * method;
    struct MonoMethod * wrapper;

    method = mono_get_context_capture_method ();
    if (method == 0B) goto <D.24861>; else goto <D.24862>;
    <D.24861>:
    D.24863 = 0B;
    return D.24863;
    <D.24862>:
    wrapper = mono_marshal_get_runtime_invoke (method, 0);
    D.24864 = mono_compile_method (wrapper);
    domain->capture_context_runtime_invoke = D.24864;
    D.24865 = mono_compile_method (method);
    domain->capture_context_method = D.24865;
  }
  <D.24857>:
  D.24858 = domain->capture_context_runtime_invoke;
  runtime_invoke = (struct MonoObject * (*RuntimeInvokeFunction) (struct MonoObject *, void * *, struct MonoObject * *, void *)) D.24858;
  D.24860 = domain->capture_context_method;
  D.24863 = runtime_invoke (0B, 0B, 0B, D.24860);
  return D.24863;
}


mono_message_init (struct MonoDomain * domain, struct MonoMethodMessage * this, struct MonoReflectionMethod * method, struct MonoArray * out_args)
{
  struct MonoMethod * D.24867;
  struct MonoClass * object_array_klass.173;
  struct MonoClass * D.24871;
  _Bool D.24872;
  long int D.24873;
  long int D.24874;
  struct MonoClass * D.24877;
  struct MonoClass * D.24880;
  struct MonoReflectionMethod * * D.24883;
  short unsigned int D.24884;
  long unsigned int D.24885;
  struct MonoVTable * D.24886;
  struct MonoArray * D.24887;
  struct MonoArray * * D.24888;
  struct MonoClass * byte_array_klass.174;
  struct MonoVTable * D.24890;
  struct MonoArray * D.24891;
  struct MonoArray * * D.24892;
  long unsigned int D.24893;
  long unsigned int D.24894;
  struct MonoClass * string_array_klass.175;
  struct MonoVTable * D.24896;
  struct MonoArray * D.24897;
  struct MonoArray * * D.24898;
  long unsigned int D.24899;
  long unsigned int D.24900;
  char * * D.24901;
  char * D.24902;
  long unsigned int D.24903;
  struct MonoArray * D.24904;
  int D.24905;
  struct MonoType * D.24906;
  unsigned char D.24907;
  unsigned char D.24908;
  long unsigned int D.24913;
  char * D.24914;
  struct MonoArray * D.24915;
  short unsigned int D.24916;
  int D.24917;
  int D.24918;
  struct MonoArray * D.24924;
  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.24867 = method->method;
  sig = mono_method_signature (D.24867);
  object_array_klass.173 = object_array_klass;
  if (object_array_klass.173 == 0B) goto <D.24869>; else goto <D.24870>;
  <D.24869>:
  {
    struct MonoClass * klass;

    D.24871 = mono_defaults.byte_class;
    klass = mono_array_class_get (D.24871, 1);
    D.24872 = klass == 0B;
    D.24873 = (long int) D.24872;
    D.24874 = __builtin_expect (D.24873, 0);
    if (D.24874 != 0) goto <D.24875>; else goto <D.24876>;
    <D.24875>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 5891, "klass");
    <D.24876>:
    byte_array_klass = klass;
    D.24877 = mono_defaults.string_class;
    klass = mono_array_class_get (D.24877, 1);
    D.24872 = klass == 0B;
    D.24873 = (long int) D.24872;
    D.24874 = __builtin_expect (D.24873, 0);
    if (D.24874 != 0) goto <D.24878>; else goto <D.24879>;
    <D.24878>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 5895, "klass");
    <D.24879>:
    string_array_klass = klass;
    D.24880 = mono_defaults.object_class;
    klass = mono_array_class_get (D.24880, 1);
    D.24872 = klass == 0B;
    D.24873 = (long int) D.24872;
    D.24874 = __builtin_expect (D.24873, 0);
    if (D.24874 != 0) goto <D.24881>; else goto <D.24882>;
    <D.24881>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 5899, "klass");
    <D.24882>:
    object_array_klass = klass;
  }
  <D.24870>:
  D.24883 = &this->method;
  mono_gc_wbarrier_set_field (this, D.24883, method);
  D.24884 = sig->param_count;
  D.24885 = (long unsigned int) D.24884;
  object_array_klass.173 = object_array_klass;
  D.24886 = mono_class_vtable (domain, object_array_klass.173);
  D.24887 = mono_array_new_specific (D.24886, D.24885);
  D.24888 = &this->args;
  mono_gc_wbarrier_set_field (this, D.24888, D.24887);
  D.24884 = sig->param_count;
  D.24885 = (long unsigned int) D.24884;
  byte_array_klass.174 = byte_array_klass;
  D.24890 = mono_class_vtable (domain, byte_array_klass.174);
  D.24891 = mono_array_new_specific (D.24890, D.24885);
  D.24892 = &this->arg_types;
  mono_gc_wbarrier_set_field (this, D.24892, D.24891);
  this->async_result = 0B;
  this->call_type = 0;
  D.24884 = sig->param_count;
  D.24893 = (long unsigned int) D.24884;
  D.24894 = D.24893 * 8;
  names = monoeg_malloc (D.24894);
  D.24867 = method->method;
  mono_method_get_param_names (D.24867, names);
  D.24884 = sig->param_count;
  D.24885 = (long unsigned int) D.24884;
  string_array_klass.175 = string_array_klass;
  D.24896 = mono_class_vtable (domain, string_array_klass.175);
  D.24897 = mono_array_new_specific (D.24896, D.24885);
  D.24898 = &this->names;
  mono_gc_wbarrier_set_field (this, D.24898, D.24897);
  i = 0;
  goto <D.20569>;
  <D.20568>:
  D.24899 = (long unsigned int) i;
  D.24900 = D.24899 * 8;
  D.24901 = names + D.24900;
  D.24902 = *D.24901;
  name = mono_string_new (domain, D.24902);
  {
    void * * __p;

    D.24903 = (long unsigned int) i;
    D.24904 = this->names;
    __p = mono_array_addr_with_size (D.24904, 8, D.24903);
    D.24904 = this->names;
    mono_gc_wbarrier_set_arrayref (D.24904, __p, name);
  }
  i = i + 1;
  <D.20569>:
  D.24884 = sig->param_count;
  D.24905 = (int) D.24884;
  if (D.24905 > i) goto <D.20568>; else goto <D.20570>;
  <D.20570>:
  monoeg_g_free (names);
  i = 0;
  j = 0;
  goto <D.20575>;
  <D.20574>:
  D.24906 = sig->params[i];
  D.24907 = BIT_FIELD_REF <*D.24906, 8, 88>;
  D.24908 = D.24907 & 64;
  if (D.24908 != 0) goto <D.24909>; else goto <D.24910>;
  <D.24909>:
  if (out_args != 0B) goto <D.24911>; else goto <D.24912>;
  <D.24911>:
  {
    struct MonoObject * arg;

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

      D.24903 = (long unsigned int) i;
      D.24915 = this->args;
      __p = mono_array_addr_with_size (D.24915, 8, D.24903);
      D.24915 = this->args;
      mono_gc_wbarrier_set_arrayref (D.24915, __p, arg);
    }
    j = j + 1;
  }
  <D.24912>:
  arg_type = 2;
  D.24906 = sig->params[i];
  D.24916 = D.24906->attrs;
  D.24917 = (int) D.24916;
  D.24918 = D.24917 & 2;
  if (D.24918 == 0) goto <D.24919>; else goto <D.24920>;
  <D.24919>:
  arg_type = arg_type | 1;
  <D.24920>:
  goto <D.24921>;
  <D.24910>:
  arg_type = 1;
  D.24906 = sig->params[i];
  D.24916 = D.24906->attrs;
  D.24917 = (int) D.24916;
  D.24918 = D.24917 & 2;
  if (D.24918 != 0) goto <D.24922>; else goto <D.24923>;
  <D.24922>:
  arg_type = arg_type | 4;
  <D.24923>:
  <D.24921>:
  {
    guint8 * __p;

    D.24903 = (long unsigned int) i;
    D.24924 = this->arg_types;
    __p = mono_array_addr_with_size (D.24924, 1, D.24903);
    *__p = arg_type;
  }
  i = i + 1;
  <D.20575>:
  D.24884 = sig->param_count;
  D.24905 = (int) D.24884;
  if (D.24905 > i) goto <D.20574>; else goto <D.20576>;
  <D.20576>:
}


mono_remoting_invoke (struct MonoObject * real_proxy, struct MonoMethodMessage * msg, struct MonoObject * * exc, struct MonoArray * * out_args)
{
  struct MonoVTable * D.24925;
  struct MonoDomain * D.24926;
  struct MonoClass * D.24929;
  _Bool D.24930;
  long int D.24931;
  long int D.24932;
  struct MonoObject * D.24935;
  struct MonoMethod * im;
  void * pa[4];

  try
    {
      D.24925 = real_proxy->vtable;
      D.24926 = D.24925->domain;
      im = D.24926->private_invoke_method;
      if (im == 0B) goto <D.24927>; else goto <D.24928>;
      <D.24927>:
      D.24929 = mono_defaults.real_proxy_class;
      im = mono_class_get_method_from_name (D.24929, "PrivateInvoke", 4);
      D.24930 = im == 0B;
      D.24931 = (long int) D.24930;
      D.24932 = __builtin_expect (D.24931, 0);
      if (D.24932 != 0) goto <D.24933>; else goto <D.24934>;
      <D.24933>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 5966, "im");
      <D.24934>:
      D.24925 = real_proxy->vtable;
      D.24926 = D.24925->domain;
      D.24926->private_invoke_method = im;
      <D.24928>:
      pa[0] = real_proxy;
      pa[1] = msg;
      pa[2] = exc;
      pa[3] = out_args;
      D.24935 = mono_runtime_invoke (im, 0B, &pa, exc);
      return D.24935;
    }
  finally
    {
      pa = {CLOBBER};
    }
}


mono_message_invoke (struct MonoObject * target, struct MonoMethodMessage * msg, struct MonoObject * * exc, struct MonoArray * * out_args)
{
  struct MonoVTable * D.24940;
  struct MonoClass * D.24941;
  struct MonoClass * D.24942;
  struct MonoRemoteClass * D.24947;
  struct MonoClass * D.24948;
  unsigned char D.24949;
  unsigned char D.24950;
  struct MonoRealProxy * D.24952;
  struct MonoObject * D.24953;
  struct MonoAppContext * D.24954;
  struct MonoObject * D.24956;
  struct MonoReflectionMethod * D.24957;
  struct MonoType * D.24958;
  unsigned char D.24959;
  unsigned char D.24960;
  short unsigned int D.24963;
  int D.24964;
  struct MonoClass * object_array_klass.176;
  struct MonoClass * D.24968;
  _Bool D.24969;
  long int D.24970;
  long int D.24971;
  long unsigned int D.24974;
  struct MonoVTable * D.24975;
  struct MonoArray * D.24976;
  struct MonoArray * D.24977;
  void * iftmp.177;
  struct MonoClass * D.24979;
  unsigned char D.24980;
  unsigned char D.24981;
  long unsigned int D.24987;
  char * D.24988;
  long unsigned int D.24989;
  struct MonoArray * D.24990;
  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.24938>; else goto <D.24939>;
  <D.24938>:
  D.24940 = target->vtable;
  D.24941 = D.24940->klass;
  D.24942 = mono_defaults.transparent_proxy_class;
  if (D.24941 == D.24942) goto <D.24943>; else goto <D.24944>;
  <D.24943>:
  {
    struct MonoTransparentProxy * tp;

    tp = target;
    D.24947 = tp->remote_class;
    D.24948 = D.24947->proxy_class;
    D.24949 = BIT_FIELD_REF <*D.24948, 8, 272>;
    D.24950 = D.24949 & 128;
    if (D.24950 != 0) goto <D.24951>; else goto <D.24945>;
    <D.24951>:
    D.24952 = tp->rp;
    D.24953 = D.24952->context;
    D.24954 = mono_context_get ();
    if (D.24953 == D.24954) goto <D.24955>; else goto <D.24945>;
    <D.24955>:
    D.24952 = tp->rp;
    target = D.24952->unwrapped_server;
    goto <D.24946>;
    <D.24945>:
    D.24952 = tp->rp;
    D.24956 = mono_remoting_invoke (D.24952, msg, exc, out_args);
    return D.24956;
    <D.24946>:
  }
  <D.24944>:
  <D.24939>:
  domain = mono_domain_get ();
  D.24957 = msg->method;
  method = D.24957->method;
  sig = mono_method_signature (method);
  i = 0;
  goto <D.20601>;
  <D.20600>:
  D.24958 = sig->params[i];
  D.24959 = BIT_FIELD_REF <*D.24958, 8, 88>;
  D.24960 = D.24959 & 64;
  if (D.24960 != 0) goto <D.24961>; else goto <D.24962>;
  <D.24961>:
  outarg_count = outarg_count + 1;
  <D.24962>:
  i = i + 1;
  <D.20601>:
  D.24963 = sig->param_count;
  D.24964 = (int) D.24963;
  if (D.24964 > i) goto <D.20600>; else goto <D.20602>;
  <D.20602>:
  object_array_klass.176 = object_array_klass;
  if (object_array_klass.176 == 0B) goto <D.24966>; else goto <D.24967>;
  <D.24966>:
  {
    struct MonoClass * klass;

    D.24968 = mono_defaults.object_class;
    klass = mono_array_class_get (D.24968, 1);
    D.24969 = klass == 0B;
    D.24970 = (long int) D.24969;
    D.24971 = __builtin_expect (D.24970, 0);
    if (D.24971 != 0) goto <D.24972>; else goto <D.24973>;
    <D.24972>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 6014, "klass");
    <D.24973>:
    mono_memory_barrier ();
    object_array_klass = klass;
  }
  <D.24967>:
  D.24974 = (long unsigned int) outarg_count;
  object_array_klass.176 = object_array_klass;
  D.24975 = mono_class_vtable (domain, object_array_klass.176);
  D.24976 = mono_array_new_specific (D.24975, D.24974);
  *out_args = D.24976;
  *exc = 0B;
  D.24977 = msg->args;
  D.24979 = method->klass;
  D.24980 = BIT_FIELD_REF <*D.24979, 8, 256>;
  D.24981 = D.24980 & 8;
  if (D.24981 != 0) goto <D.24982>; else goto <D.24983>;
  <D.24982>:
  iftmp.177 = mono_object_unbox (target);
  goto <D.24984>;
  <D.24983>:
  iftmp.177 = target;
  <D.24984>:
  ret = mono_runtime_invoke_array (method, iftmp.177, D.24977, exc);
  i = 0;
  j = 0;
  goto <D.20607>;
  <D.20606>:
  D.24958 = sig->params[i];
  D.24959 = BIT_FIELD_REF <*D.24958, 8, 88>;
  D.24960 = D.24959 & 64;
  if (D.24960 != 0) goto <D.24985>; else goto <D.24986>;
  <D.24985>:
  {
    struct MonoObject * arg;

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

      D.24989 = (long unsigned int) j;
      D.24990 = *out_args;
      __p = mono_array_addr_with_size (D.24990, 8, D.24989);
      D.24990 = *out_args;
      mono_gc_wbarrier_set_arrayref (D.24990, __p, arg);
    }
    j = j + 1;
  }
  <D.24986>:
  i = i + 1;
  <D.20607>:
  D.24963 = sig->param_count;
  D.24964 = (int) D.24963;
  if (D.24964 > i) goto <D.20606>; else goto <D.20608>;
  <D.20608>:
  D.24956 = ret;
  return D.24956;
}


mono_object_to_string (struct MonoObject * obj, struct MonoObject * * exc)
{
  _Bool D.24992;
  long int D.24993;
  long int D.24994;
  struct MonoMethod * to_string.178;
  struct MonoClass * D.25000;
  struct MonoMethod * to_string.179;
  struct MonoClass * D.25002;
  int D.25003;
  struct MonoString * D.25006;
  static struct MonoMethod * to_string = 0B;
  struct MonoMethod * method;
  void * target;

  target = obj;
  D.24992 = obj == 0B;
  D.24993 = (long int) D.24992;
  D.24994 = __builtin_expect (D.24993, 0);
  if (D.24994 != 0) goto <D.24995>; else goto <D.24996>;
  <D.24995>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 6052, "obj");
  <D.24996>:
  to_string.178 = to_string;
  if (to_string.178 == 0B) goto <D.24998>; else goto <D.24999>;
  <D.24998>:
  D.25000 = mono_get_object_class ();
  to_string.179 = mono_class_get_method_from_name_flags (D.25000, "ToString", 0, 70);
  to_string = to_string.179;
  <D.24999>:
  to_string.178 = to_string;
  method = mono_object_get_virtual_method (obj, to_string.178);
  D.25002 = mono_method_get_class (method);
  D.25003 = mono_class_is_valuetype (D.25002);
  if (D.25003 != 0) goto <D.25004>; else goto <D.25005>;
  <D.25004>:
  target = mono_object_unbox (obj);
  <D.25005>:
  D.25006 = mono_runtime_invoke (method, target, 0B, exc);
  return D.25006;
}


mono_print_unhandled_exception (struct MonoObject * exc)
{
  struct MonoVTable * D.25008;
  struct MonoDomain * D.25009;
  struct MonoException * D.25010;
  struct MonoArray * D.25014;
  struct MonoObject * other_exc.180;
  int D.25024;
  struct MonoString * str;
  char * message;
  gboolean free_message;
  struct MonoError error;

  try
    {
      message = "";
      free_message = 0;
      D.25008 = exc->vtable;
      D.25009 = D.25008->domain;
      D.25010 = D.25009->out_of_memory_ex;
      if (D.25010 == exc) goto <D.25011>; else goto <D.25012>;
      <D.25011>:
      message = monoeg_strdup ("OutOfMemoryException");
      free_message = 1;
      goto <D.25013>;
      <D.25012>:
      D.25014 = MEM[(struct MonoException *)exc].native_trace_ips;
      if (D.25014 != 0B) goto <D.25015>; else goto <D.25016>;
      <D.25015>:
      message = mono_exception_get_native_backtrace (exc);
      free_message = 1;
      goto <D.25017>;
      <D.25016>:
      {
        struct MonoObject * other_exc;

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

              original_backtrace = mono_exception_get_managed_backtrace (exc);
              other_exc.180 = other_exc;
              nested_backtrace = mono_exception_get_managed_backtrace (other_exc.180);
              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.25021>;
            <D.25020>:
            if (str != 0B) goto <D.25022>; else goto <D.25023>;
            <D.25022>:
            message = mono_string_to_utf8_checked (str, &error);
            D.25024 = mono_error_ok (&error);
            if (D.25024 == 0) goto <D.25025>; else goto <D.25026>;
            <D.25025>:
            mono_error_cleanup (&error);
            message = "";
            goto <D.25027>;
            <D.25026>:
            free_message = 1;
            <D.25027>:
            <D.25023>:
            <D.25021>:
          }
        finally
          {
            other_exc = {CLOBBER};
          }
      }
      <D.25017>:
      <D.25013>:
      monoeg_g_printerr ("\nUnhandled Exception:\n%s\n", message);
      if (free_message != 0) goto <D.25028>; else goto <D.25029>;
      <D.25028>:
      monoeg_g_free (message);
      <D.25029>:
    }
  finally
    {
      error = {CLOBBER};
    }
}


mono_delegate_ctor_with_method (struct MonoObject * this, struct MonoObject * target, void * addr, struct MonoMethod * method)
{
  _Bool D.25030;
  long int D.25031;
  long int D.25032;
  _Bool D.25035;
  long int D.25036;
  long int D.25037;
  struct MonoVTable * D.25042;
  long unsigned int D.25043;
  long unsigned int D.25044;
  struct MonoVTable * D.25048;
  struct MonoClass * D.25049;
  struct MonoClass * D.25050;
  _Bool D.25052;
  long int D.25053;
  long int D.25054;
  void * D.25057;
  struct MonoObject * * D.25058;
  void * (*<T1df0>) (struct MonoDomain *, struct MonoClass *) arch_create_delegate_trampoline.181;
  struct MonoVTable * D.25060;
  struct MonoClass * D.25061;
  struct MonoDomain * D.25062;
  void * D.25063;
  struct MonoDelegate * delegate;
  struct MonoClass * class;

  delegate = this;
  D.25030 = this == 0B;
  D.25031 = (long int) D.25030;
  D.25032 = __builtin_expect (D.25031, 0);
  if (D.25032 != 0) goto <D.25033>; else goto <D.25034>;
  <D.25033>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 6142, "this");
  <D.25034>:
  D.25035 = addr == 0B;
  D.25036 = (long int) D.25035;
  D.25037 = __builtin_expect (D.25036, 0);
  if (D.25037 != 0) goto <D.25038>; else goto <D.25039>;
  <D.25038>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 6143, "addr");
  <D.25039>:
  if (method != 0B) goto <D.25040>; else goto <D.25041>;
  <D.25040>:
  delegate->method = method;
  <D.25041>:
  D.25042 = this->vtable;
  class = D.25042->klass;
  D.25043 = mono_stats.delegate_creations;
  D.25044 = D.25043 + 1;
  mono_stats.delegate_creations = D.25044;
  if (target != 0B) goto <D.25047>; else goto <D.25045>;
  <D.25047>:
  D.25048 = target->vtable;
  D.25049 = D.25048->klass;
  D.25050 = mono_defaults.transparent_proxy_class;
  if (D.25049 == D.25050) goto <D.25051>; else goto <D.25045>;
  <D.25051>:
  D.25052 = method == 0B;
  D.25053 = (long int) D.25052;
  D.25054 = __builtin_expect (D.25053, 0);
  if (D.25054 != 0) goto <D.25055>; else goto <D.25056>;
  <D.25055>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 6153, "method");
  <D.25056>:
  method = mono_marshal_get_remoting_invoke (method);
  D.25057 = mono_compile_method (method);
  delegate->method_ptr = D.25057;
  D.25058 = &delegate->target;
  mono_gc_wbarrier_set_field (delegate, D.25058, target);
  goto <D.25046>;
  <D.25045>:
  delegate->method_ptr = addr;
  D.25058 = &delegate->target;
  mono_gc_wbarrier_set_field (delegate, D.25058, target);
  <D.25046>:
  arch_create_delegate_trampoline.181 = arch_create_delegate_trampoline;
  D.25060 = delegate->object.vtable;
  D.25061 = D.25060->klass;
  D.25060 = delegate->object.vtable;
  D.25062 = D.25060->domain;
  D.25063 = arch_create_delegate_trampoline.181 (D.25062, D.25061);
  delegate->invoke_impl = D.25063;
}


mono_delegate_ctor (struct MonoObject * this, struct MonoObject * target, void * addr)
{
  _Bool D.25064;
  long int D.25065;
  long int D.25066;
  void * D.25069;
  struct MonoDomain * D.25072;
  void * D.25075;
  struct MonoDomain * D.25076;
  struct MonoClass * D.25079;
  struct MonoGenericContainer * D.25080;
  _Bool D.25081;
  long int D.25082;
  long int D.25083;
  struct MonoDomain * domain;
  struct MonoJitInfo * ji;
  struct MonoMethod * method;

  domain = mono_domain_get ();
  method = 0B;
  D.25064 = addr == 0B;
  D.25065 = (long int) D.25064;
  D.25066 = __builtin_expect (D.25065, 0);
  if (D.25066 != 0) goto <D.25067>; else goto <D.25068>;
  <D.25067>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 6182, "addr");
  <D.25068>:
  D.25069 = mono_get_addr_from_ftnptr (addr);
  ji = mono_jit_info_table_find (domain, D.25069);
  if (ji == 0B) goto <D.25070>; else goto <D.25071>;
  <D.25070>:
  D.25072 = mono_get_root_domain ();
  if (D.25072 != domain) goto <D.25073>; else goto <D.25074>;
  <D.25073>:
  D.25075 = mono_get_addr_from_ftnptr (addr);
  D.25076 = mono_get_root_domain ();
  ji = mono_jit_info_table_find (D.25076, D.25075);
  <D.25074>:
  <D.25071>:
  if (ji != 0B) goto <D.25077>; else goto <D.25078>;
  <D.25077>:
  method = mono_jit_info_get_method (ji);
  D.25079 = method->klass;
  D.25080 = D.25079->generic_container;
  D.25081 = D.25080 != 0B;
  D.25082 = (long int) D.25081;
  D.25083 = __builtin_expect (D.25082, 0);
  if (D.25083 != 0) goto <D.25084>; else goto <D.25085>;
  <D.25084>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 6190, "!method->klass->generic_container");
  <D.25085>:
  <D.25078>:
  mono_delegate_ctor_with_method (this, target, addr, method);
}


mono_method_call_message_new (struct MonoMethod * method, void * * params, struct MonoMethod * invoke, struct MonoDelegate * * cb, struct MonoObject * * state)
{
  struct MonoClass * D.25086;
  struct MonoReflectionMethod * D.25089;
  short unsigned int D.25090;
  int D.25091;
  struct MonoReflectionMethod * D.25093;
  struct MonoType * D.25094;
  unsigned char D.25095;
  unsigned char D.25096;
  long unsigned int D.25099;
  long unsigned int D.25100;
  void * * D.25101;
  void * D.25102;
  unsigned char D.25104;
  unsigned char D.25105;
  unsigned char D.25106;
  long unsigned int D.25110;
  struct MonoArray * D.25111;
  _Bool D.25112;
  _Bool D.25113;
  _Bool D.25114;
  struct MonoDelegate * D.25117;
  struct MonoObject * D.25118;
  struct MonoMethodMessage * D.25119;
  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.25086 = mono_defaults.mono_method_message_class;
  msg = mono_object_new (domain, D.25086);
  if (invoke != 0B) goto <D.25087>; else goto <D.25088>;
  <D.25087>:
  D.25089 = mono_method_get_object (domain, invoke, 0B);
  mono_message_init (domain, msg, D.25089, 0B);
  D.25090 = sig->param_count;
  D.25091 = (int) D.25090;
  count = D.25091 + -2;
  goto <D.25092>;
  <D.25088>:
  D.25093 = mono_method_get_object (domain, method, 0B);
  mono_message_init (domain, msg, D.25093, 0B);
  D.25090 = sig->param_count;
  count = (int) D.25090;
  <D.25092>:
  i = 0;
  goto <D.20660>;
  <D.20659>:
  {
    void * vpos;
    struct MonoClass * class;
    struct MonoObject * arg;

    D.25094 = sig->params[i];
    D.25095 = BIT_FIELD_REF <*D.25094, 8, 88>;
    D.25096 = D.25095 & 64;
    if (D.25096 != 0) goto <D.25097>; else goto <D.25098>;
    <D.25097>:
    D.25099 = (long unsigned int) i;
    D.25100 = D.25099 * 8;
    D.25101 = params + D.25100;
    D.25102 = *D.25101;
    vpos = MEM[(void * *)D.25102];
    goto <D.25103>;
    <D.25098>:
    D.25099 = (long unsigned int) i;
    D.25100 = D.25099 * 8;
    D.25101 = params + D.25100;
    vpos = *D.25101;
    <D.25103>:
    D.25094 = sig->params[i];
    D.25104 = D.25094->type;
    type = (int) D.25104;
    D.25094 = sig->params[i];
    class = mono_class_from_mono_type (D.25094);
    D.25105 = BIT_FIELD_REF <*class, 8, 256>;
    D.25106 = D.25105 & 8;
    if (D.25106 != 0) goto <D.25107>; else goto <D.25108>;
    <D.25107>:
    arg = mono_value_box (domain, class, vpos);
    goto <D.25109>;
    <D.25108>:
    arg = MEM[(struct MonoObject * *)vpos];
    <D.25109>:
    {
      void * * __p;

      D.25110 = (long unsigned int) i;
      D.25111 = msg->args;
      __p = mono_array_addr_with_size (D.25111, 8, D.25110);
      D.25111 = msg->args;
      mono_gc_wbarrier_set_arrayref (D.25111, __p, arg);
    }
  }
  i = i + 1;
  <D.20660>:
  if (i < count) goto <D.20659>; else goto <D.20661>;
  <D.20661>:
  D.25112 = cb != 0B;
  D.25113 = state != 0B;
  D.25114 = D.25112 & D.25113;
  if (D.25114 != 0) goto <D.25115>; else goto <D.25116>;
  <D.25115>:
  D.25099 = (long unsigned int) i;
  D.25100 = D.25099 * 8;
  D.25101 = params + D.25100;
  D.25102 = *D.25101;
  D.25117 = MEM[(struct MonoDelegate * *)D.25102];
  *cb = D.25117;
  i = i + 1;
  D.25099 = (long unsigned int) i;
  D.25100 = D.25099 * 8;
  D.25101 = params + D.25100;
  D.25102 = *D.25101;
  D.25118 = MEM[(struct MonoObject * *)D.25102];
  *state = D.25118;
  <D.25116>:
  D.25119 = msg;
  return D.25119;
}


mono_method_return_message_restore (struct MonoMethod * method, void * * params, struct MonoArray * out_args)
{
  long unsigned int D.25123;
  unsigned char D.25126;
  unsigned char D.25127;
  struct MonoException * D.25132;
  long unsigned int D.25133;
  char * D.25134;
  unsigned char D.25135;
  _Bool D.25136;
  long int D.25137;
  long int D.25138;
  int D.25141;
  long unsigned int D.25144;
  long unsigned int D.25145;
  void * * D.25146;
  void * D.25147;
  struct MonoObject * * D.25148;
  struct MonoVTable * D.25152;
  unsigned char D.25153;
  unsigned char D.25154;
  void * D.25157;
  void * D.25158;
  long unsigned int D.25160;
  const void * D.25161;
  struct MonoClass * D.25163;
  short unsigned int D.25164;
  int D.25165;
  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.25121>; else goto <D.25122>;
  <D.25121>:
  return;
  <D.25122>:
  D.25123 = mono_array_length (out_args);
  out_len = (int) D.25123;
  if (out_len == 0) goto <D.25124>; else goto <D.25125>;
  <D.25124>:
  return;
  <D.25125>:
  i = 0;
  j = 0;
  goto <D.20677>;
  <D.20676>:
  {
    struct MonoType * pt;

    pt = sig->params[i];
    D.25126 = BIT_FIELD_REF <*pt, 8, 88>;
    D.25127 = D.25126 & 64;
    if (D.25127 != 0) goto <D.25128>; else goto <D.25129>;
    <D.25128>:
    {
      char * arg;

      if (j >= out_len) goto <D.25130>; else goto <D.25131>;
      <D.25130>:
      D.25132 = mono_get_exception_execution_engine ("The proxy call returned an incorrect number of output arguments");
      mono_raise_exception (D.25132);
      <D.25131>:
      D.25133 = (long unsigned int) j;
      D.25134 = mono_array_addr_with_size (out_args, 8, D.25133);
      arg = MEM[(void * *)D.25134];
      D.25135 = pt->type;
      type = (int) D.25135;
      D.25136 = type == 1;
      D.25137 = (long int) D.25136;
      D.25138 = __builtin_expect (D.25137, 0);
      if (D.25138 != 0) goto <D.25139>; else goto <D.25140>;
      <D.25139>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 6283, "type != MONO_TYPE_VOID");
      <D.25140>:
      D.25141 = mono_type_is_reference (pt);
      if (D.25141 != 0) goto <D.25142>; else goto <D.25143>;
      <D.25142>:
      D.25144 = (long unsigned int) i;
      D.25145 = D.25144 * 8;
      D.25146 = params + D.25145;
      D.25147 = *D.25146;
      D.25148 = MEM[(struct MonoObject * * *)D.25147];
      mono_gc_wbarrier_generic_store (D.25148, arg);
      goto <D.25149>;
      <D.25143>:
      if (arg != 0B) goto <D.25150>; else goto <D.25151>;
      <D.25150>:
      {
        struct MonoClass * class;

        D.25152 = MEM[(struct MonoObject *)arg].vtable;
        class = D.25152->klass;
        size = mono_class_value_size (class, 0B);
        D.25153 = BIT_FIELD_REF <*class, 8, 280>;
        D.25154 = D.25153 & 8;
        if (D.25154 != 0) goto <D.25155>; else goto <D.25156>;
        <D.25155>:
        D.25157 = arg + 16;
        D.25144 = (long unsigned int) i;
        D.25145 = D.25144 * 8;
        D.25146 = params + D.25145;
        D.25147 = *D.25146;
        D.25158 = MEM[(void * *)D.25147];
        mono_gc_wbarrier_value_copy (D.25158, D.25157, 1, class);
        goto <D.25159>;
        <D.25156>:
        D.25160 = (long unsigned int) size;
        D.25161 = arg + 16;
        D.25144 = (long unsigned int) i;
        D.25145 = D.25144 * 8;
        D.25146 = params + D.25145;
        D.25147 = *D.25146;
        D.25158 = MEM[(void * *)D.25147];
        mono_gc_memmove_atomic (D.25158, D.25161, D.25160);
        <D.25159>:
      }
      goto <D.25162>;
      <D.25151>:
      D.25163 = mono_class_from_mono_type (pt);
      size = mono_class_value_size (D.25163, 0B);
      D.25160 = (long unsigned int) size;
      D.25144 = (long unsigned int) i;
      D.25145 = D.25144 * 8;
      D.25146 = params + D.25145;
      D.25147 = *D.25146;
      D.25158 = MEM[(void * *)D.25147];
      mono_gc_bzero_atomic (D.25158, D.25160);
      <D.25162>:
      <D.25149>:
      j = j + 1;
    }
    <D.25129>:
  }
  i = i + 1;
  <D.20677>:
  D.25164 = sig->param_count;
  D.25165 = (int) D.25164;
  if (D.25165 > i) goto <D.20676>; else goto <D.20678>;
  <D.20678>:
}


mono_load_remote_field (struct MonoObject * this, struct MonoClass * klass, struct MonoClassField * field, void * * res)
{
  struct MonoVTable * D.25167;
  struct MonoClass * D.25168;
  struct MonoClass * D.25169;
  _Bool D.25170;
  long int D.25171;
  long int D.25172;
  _Bool D.25175;
  long int D.25176;
  long int D.25177;
  struct MonoRemoteClass * D.25180;
  struct MonoClass * D.25181;
  unsigned char D.25182;
  unsigned char D.25183;
  struct MonoRealProxy * D.25186;
  struct MonoObject * D.25187;
  struct MonoAppContext * D.25188;
  struct MonoObject * D.25191;
  void * D.25192;
  struct MonoMethod * getter.182;
  struct MonoClass * D.25196;
  struct MonoMethod * getter.183;
  _Bool D.25198;
  long int D.25199;
  long int D.25200;
  struct MonoType * D.25203;
  struct MonoClass * D.25204;
  struct MonoArray * out_args.184;
  struct MonoArray * out_args.185;
  struct MonoReflectionMethod * D.25207;
  struct MonoArray * D.25208;
  struct MonoString * D.25209;
  const char * D.25210;
  struct MonoString * D.25211;
  struct MonoObject * exc.186;
  long unsigned int D.25215;
  char * D.25218;
  struct MonoObject * D.25219;
  unsigned char D.25220;
  unsigned char D.25221;
  void * D.25224;
  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.25167 = this->vtable;
      D.25168 = D.25167->klass;
      D.25169 = mono_defaults.transparent_proxy_class;
      D.25170 = D.25168 != D.25169;
      D.25171 = (long int) D.25170;
      D.25172 = __builtin_expect (D.25171, 0);
      if (D.25172 != 0) goto <D.25173>; else goto <D.25174>;
      <D.25173>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 6334, "mono_object_is_transparent_proxy (this)");
      <D.25174>:
      D.25175 = res == 0B;
      D.25176 = (long int) D.25175;
      D.25177 = __builtin_expect (D.25176, 0);
      if (D.25177 != 0) goto <D.25178>; else goto <D.25179>;
      <D.25178>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 6335, "res != NULL");
      <D.25179>:
      D.25180 = tp->remote_class;
      D.25181 = D.25180->proxy_class;
      D.25182 = BIT_FIELD_REF <*D.25181, 8, 272>;
      D.25183 = D.25182 & 128;
      if (D.25183 != 0) goto <D.25184>; else goto <D.25185>;
      <D.25184>:
      D.25186 = tp->rp;
      D.25187 = D.25186->context;
      D.25188 = mono_context_get ();
      if (D.25187 == D.25188) goto <D.25189>; else goto <D.25190>;
      <D.25189>:
      D.25186 = tp->rp;
      D.25191 = D.25186->unwrapped_server;
      mono_field_get_value (D.25191, field, res);
      D.25192 = res;
      return D.25192;
      <D.25190>:
      <D.25185>:
      getter.182 = getter;
      if (getter.182 == 0B) goto <D.25194>; else goto <D.25195>;
      <D.25194>:
      D.25196 = mono_defaults.object_class;
      getter.183 = mono_class_get_method_from_name (D.25196, "FieldGetter", -1);
      getter = getter.183;
      getter.182 = getter;
      D.25198 = getter.182 == 0B;
      D.25199 = (long int) D.25198;
      D.25200 = __builtin_expect (D.25199, 0);
      if (D.25200 != 0) goto <D.25201>; else goto <D.25202>;
      <D.25201>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 6344, "getter");
      <D.25202>:
      <D.25195>:
      D.25203 = field->type;
      field_class = mono_class_from_mono_type (D.25203);
      D.25204 = mono_defaults.mono_method_message_class;
      msg = mono_object_new (domain, D.25204);
      D.25196 = mono_defaults.object_class;
      out_args.184 = mono_array_new (domain, D.25196, 1);
      out_args = out_args.184;
      out_args.185 = out_args;
      getter.182 = getter;
      D.25207 = mono_method_get_object (domain, getter.182, 0B);
      mono_message_init (domain, msg, D.25207, out_args.185);
      full_name = mono_type_get_full_name (klass);
      {
        void * * __p;

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

        D.25208 = msg->args;
        __p = mono_array_addr_with_size (D.25208, 8, 1);
        D.25210 = mono_field_get_name (field);
        D.25211 = mono_string_new (domain, D.25210);
        D.25208 = msg->args;
        mono_gc_wbarrier_set_arrayref (D.25208, __p, D.25211);
      }
      monoeg_g_free (full_name);
      D.25186 = tp->rp;
      mono_remoting_invoke (D.25186, msg, &exc, &out_args);
      exc.186 = exc;
      if (exc.186 != 0B) goto <D.25213>; else goto <D.25214>;
      <D.25213>:
      exc.186 = exc;
      mono_raise_exception (exc.186);
      <D.25214>:
      out_args.185 = out_args;
      D.25215 = mono_array_length (out_args.185);
      if (D.25215 == 0) goto <D.25216>; else goto <D.25217>;
      <D.25216>:
      D.25192 = 0B;
      return D.25192;
      <D.25217>:
      out_args.185 = out_args;
      D.25218 = mono_array_addr_with_size (out_args.185, 8, 0);
      D.25219 = MEM[(struct MonoObject * *)D.25218];
      *res = D.25219;
      D.25220 = BIT_FIELD_REF <*field_class, 8, 256>;
      D.25221 = D.25220 & 8;
      if (D.25221 != 0) goto <D.25222>; else goto <D.25223>;
      <D.25222>:
      D.25224 = *res;
      D.25192 = D.25224 + 16;
      return D.25192;
      <D.25223>:
      D.25192 = res;
      return D.25192;
    }
  finally
    {
      out_args = {CLOBBER};
      exc = {CLOBBER};
    }
}


mono_load_remote_field_new (struct MonoObject * this, struct MonoClass * klass, struct MonoClassField * field)
{
  struct MonoVTable * D.25227;
  struct MonoClass * D.25228;
  struct MonoClass * D.25229;
  _Bool D.25230;
  long int D.25231;
  long int D.25232;
  struct MonoType * D.25235;
  struct MonoRemoteClass * D.25236;
  struct MonoClass * D.25237;
  unsigned char D.25238;
  unsigned char D.25239;
  struct MonoRealProxy * D.25242;
  struct MonoObject * D.25243;
  struct MonoAppContext * D.25244;
  unsigned char D.25247;
  unsigned char D.25248;
  struct MonoObject * res.187;
  struct MonoObject * res.188;
  struct MonoObject * D.25254;
  struct MonoObject * D.25255;
  struct MonoMethod * getter.189;
  struct MonoClass * D.25259;
  struct MonoMethod * getter.190;
  _Bool D.25261;
  long int D.25262;
  long int D.25263;
  struct MonoClass * D.25266;
  struct MonoArray * out_args.191;
  struct MonoArray * out_args.192;
  struct MonoReflectionMethod * D.25269;
  struct MonoArray * D.25270;
  struct MonoString * D.25271;
  const char * D.25272;
  struct MonoString * D.25273;
  struct MonoObject * exc.193;
  long unsigned int D.25277;
  char * D.25281;
  struct MonoObject * res.194;
  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.25227 = this->vtable;
      D.25228 = D.25227->klass;
      D.25229 = mono_defaults.transparent_proxy_class;
      D.25230 = D.25228 != D.25229;
      D.25231 = (long int) D.25230;
      D.25232 = __builtin_expect (D.25231, 0);
      if (D.25232 != 0) goto <D.25233>; else goto <D.25234>;
      <D.25233>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 6393, "mono_object_is_transparent_proxy (this)");
      <D.25234>:
      D.25235 = field->type;
      field_class = mono_class_from_mono_type (D.25235);
      D.25236 = tp->remote_class;
      D.25237 = D.25236->proxy_class;
      D.25238 = BIT_FIELD_REF <*D.25237, 8, 272>;
      D.25239 = D.25238 & 128;
      if (D.25239 != 0) goto <D.25240>; else goto <D.25241>;
      <D.25240>:
      D.25242 = tp->rp;
      D.25243 = D.25242->context;
      D.25244 = mono_context_get ();
      if (D.25243 == D.25244) goto <D.25245>; else goto <D.25246>;
      <D.25245>:
      {
        void * val;

        D.25247 = BIT_FIELD_REF <*field_class, 8, 256>;
        D.25248 = D.25247 & 8;
        if (D.25248 != 0) goto <D.25249>; else goto <D.25250>;
        <D.25249>:
        res.187 = mono_object_new (domain, field_class);
        res = res.187;
        res.188 = res;
        val = res.188 + 16;
        goto <D.25253>;
        <D.25250>:
        val = &res;
        <D.25253>:
        D.25242 = tp->rp;
        D.25254 = D.25242->unwrapped_server;
        mono_field_get_value (D.25254, field, val);
        D.25255 = res;
        return D.25255;
      }
      <D.25246>:
      <D.25241>:
      getter.189 = getter;
      if (getter.189 == 0B) goto <D.25257>; else goto <D.25258>;
      <D.25257>:
      D.25259 = mono_defaults.object_class;
      getter.190 = mono_class_get_method_from_name (D.25259, "FieldGetter", -1);
      getter = getter.190;
      getter.189 = getter;
      D.25261 = getter.189 == 0B;
      D.25262 = (long int) D.25261;
      D.25263 = __builtin_expect (D.25262, 0);
      if (D.25263 != 0) goto <D.25264>; else goto <D.25265>;
      <D.25264>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 6411, "getter");
      <D.25265>:
      <D.25258>:
      D.25266 = mono_defaults.mono_method_message_class;
      msg = mono_object_new (domain, D.25266);
      D.25259 = mono_defaults.object_class;
      out_args.191 = mono_array_new (domain, D.25259, 1);
      out_args = out_args.191;
      out_args.192 = out_args;
      getter.189 = getter;
      D.25269 = mono_method_get_object (domain, getter.189, 0B);
      mono_message_init (domain, msg, D.25269, out_args.192);
      full_name = mono_type_get_full_name (klass);
      {
        void * * __p;

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

        D.25270 = msg->args;
        __p = mono_array_addr_with_size (D.25270, 8, 1);
        D.25272 = mono_field_get_name (field);
        D.25273 = mono_string_new (domain, D.25272);
        D.25270 = msg->args;
        mono_gc_wbarrier_set_arrayref (D.25270, __p, D.25273);
      }
      monoeg_g_free (full_name);
      D.25242 = tp->rp;
      mono_remoting_invoke (D.25242, msg, &exc, &out_args);
      exc.193 = exc;
      if (exc.193 != 0B) goto <D.25275>; else goto <D.25276>;
      <D.25275>:
      exc.193 = exc;
      mono_raise_exception (exc.193);
      <D.25276>:
      out_args.192 = out_args;
      D.25277 = mono_array_length (out_args.192);
      if (D.25277 == 0) goto <D.25278>; else goto <D.25279>;
      <D.25278>:
      res = 0B;
      goto <D.25280>;
      <D.25279>:
      out_args.192 = out_args;
      D.25281 = mono_array_addr_with_size (out_args.192, 8, 0);
      res.194 = MEM[(struct MonoObject * *)D.25281];
      res = res.194;
      <D.25280>:
      D.25255 = res;
      return D.25255;
    }
  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.25285;
  struct MonoClass * D.25286;
  struct MonoClass * D.25287;
  _Bool D.25288;
  long int D.25289;
  long int D.25290;
  struct MonoType * D.25293;
  struct MonoRemoteClass * D.25294;
  struct MonoClass * D.25295;
  unsigned char D.25296;
  unsigned char D.25297;
  struct MonoRealProxy * D.25300;
  struct MonoObject * D.25301;
  struct MonoAppContext * D.25302;
  unsigned char D.25305;
  unsigned char D.25306;
  struct MonoObject * D.25309;
  struct MonoObject * D.25311;
  struct MonoMethod * setter.195;
  struct MonoClass * D.25315;
  struct MonoMethod * setter.196;
  _Bool D.25317;
  long int D.25318;
  long int D.25319;
  struct MonoClass * D.25325;
  struct MonoReflectionMethod * D.25326;
  struct MonoArray * D.25327;
  struct MonoString * D.25328;
  const char * D.25329;
  struct MonoString * D.25330;
  struct MonoObject * exc.197;
  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.25285 = this->vtable;
      D.25286 = D.25285->klass;
      D.25287 = mono_defaults.transparent_proxy_class;
      D.25288 = D.25286 != D.25287;
      D.25289 = (long int) D.25288;
      D.25290 = __builtin_expect (D.25289, 0);
      if (D.25290 != 0) goto <D.25291>; else goto <D.25292>;
      <D.25291>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 6460, "mono_object_is_transparent_proxy (this)");
      <D.25292>:
      D.25293 = field->type;
      field_class = mono_class_from_mono_type (D.25293);
      D.25294 = tp->remote_class;
      D.25295 = D.25294->proxy_class;
      D.25296 = BIT_FIELD_REF <*D.25295, 8, 272>;
      D.25297 = D.25296 & 128;
      if (D.25297 != 0) goto <D.25298>; else goto <D.25299>;
      <D.25298>:
      D.25300 = tp->rp;
      D.25301 = D.25300->context;
      D.25302 = mono_context_get ();
      if (D.25301 == D.25302) goto <D.25303>; else goto <D.25304>;
      <D.25303>:
      D.25305 = BIT_FIELD_REF <*field_class, 8, 256>;
      D.25306 = D.25305 & 8;
      if (D.25306 != 0) goto <D.25307>; else goto <D.25308>;
      <D.25307>:
      D.25300 = tp->rp;
      D.25309 = D.25300->unwrapped_server;
      mono_field_set_value (D.25309, field, val);
      goto <D.25310>;
      <D.25308>:
      D.25311 = MEM[(struct MonoObject * *)val];
      D.25300 = tp->rp;
      D.25309 = D.25300->unwrapped_server;
      mono_field_set_value (D.25309, field, D.25311);
      <D.25310>:
      return;
      <D.25304>:
      <D.25299>:
      setter.195 = setter;
      if (setter.195 == 0B) goto <D.25313>; else goto <D.25314>;
      <D.25313>:
      D.25315 = mono_defaults.object_class;
      setter.196 = mono_class_get_method_from_name (D.25315, "FieldSetter", -1);
      setter = setter.196;
      setter.195 = setter;
      D.25317 = setter.195 == 0B;
      D.25318 = (long int) D.25317;
      D.25319 = __builtin_expect (D.25318, 0);
      if (D.25319 != 0) goto <D.25320>; else goto <D.25321>;
      <D.25320>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 6472, "setter");
      <D.25321>:
      <D.25314>:
      D.25305 = BIT_FIELD_REF <*field_class, 8, 256>;
      D.25306 = D.25305 & 8;
      if (D.25306 != 0) goto <D.25322>; else goto <D.25323>;
      <D.25322>:
      arg = mono_value_box (domain, field_class, val);
      goto <D.25324>;
      <D.25323>:
      arg = MEM[(struct MonoObject * *)val];
      <D.25324>:
      D.25325 = mono_defaults.mono_method_message_class;
      msg = mono_object_new (domain, D.25325);
      setter.195 = setter;
      D.25326 = mono_method_get_object (domain, setter.195, 0B);
      mono_message_init (domain, msg, D.25326, 0B);
      full_name = mono_type_get_full_name (klass);
      {
        void * * __p;

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

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

        D.25327 = msg->args;
        __p = mono_array_addr_with_size (D.25327, 8, 2);
        D.25327 = msg->args;
        mono_gc_wbarrier_set_arrayref (D.25327, __p, arg);
      }
      monoeg_g_free (full_name);
      D.25300 = tp->rp;
      mono_remoting_invoke (D.25300, msg, &exc, &out_args);
      exc.197 = exc;
      if (exc.197 != 0B) goto <D.25332>; else goto <D.25333>;
      <D.25332>:
      exc.197 = exc;
      mono_raise_exception (exc.197);
      <D.25333>:
    }
  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.25337;
  struct MonoClass * D.25338;
  struct MonoClass * D.25339;
  _Bool D.25340;
  long int D.25341;
  long int D.25342;
  struct MonoType * D.25345;
  struct MonoRemoteClass * D.25346;
  struct MonoClass * D.25347;
  unsigned char D.25348;
  unsigned char D.25349;
  struct MonoRealProxy * D.25352;
  struct MonoObject * D.25353;
  struct MonoAppContext * D.25354;
  unsigned char D.25357;
  unsigned char D.25358;
  void * D.25361;
  struct MonoObject * D.25362;
  struct MonoMethod * setter.198;
  struct MonoClass * D.25367;
  struct MonoMethod * setter.199;
  _Bool D.25369;
  long int D.25370;
  long int D.25371;
  struct MonoClass * D.25374;
  struct MonoReflectionMethod * D.25375;
  struct MonoArray * D.25376;
  struct MonoString * D.25377;
  const char * D.25378;
  struct MonoString * D.25379;
  struct MonoObject * exc.200;
  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.25337 = this->vtable;
      D.25338 = D.25337->klass;
      D.25339 = mono_defaults.transparent_proxy_class;
      D.25340 = D.25338 != D.25339;
      D.25341 = (long int) D.25340;
      D.25342 = __builtin_expect (D.25341, 0);
      if (D.25342 != 0) goto <D.25343>; else goto <D.25344>;
      <D.25343>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 6516, "mono_object_is_transparent_proxy (this)");
      <D.25344>:
      D.25345 = field->type;
      field_class = mono_class_from_mono_type (D.25345);
      D.25346 = tp->remote_class;
      D.25347 = D.25346->proxy_class;
      D.25348 = BIT_FIELD_REF <*D.25347, 8, 272>;
      D.25349 = D.25348 & 128;
      if (D.25349 != 0) goto <D.25350>; else goto <D.25351>;
      <D.25350>:
      D.25352 = tp->rp;
      D.25353 = D.25352->context;
      D.25354 = mono_context_get ();
      if (D.25353 == D.25354) goto <D.25355>; else goto <D.25356>;
      <D.25355>:
      D.25357 = BIT_FIELD_REF <*field_class, 8, 256>;
      D.25358 = D.25357 & 8;
      if (D.25358 != 0) goto <D.25359>; else goto <D.25360>;
      <D.25359>:
      D.25361 = arg + 16;
      D.25352 = tp->rp;
      D.25362 = D.25352->unwrapped_server;
      mono_field_set_value (D.25362, field, D.25361);
      goto <D.25363>;
      <D.25360>:
      D.25352 = tp->rp;
      D.25362 = D.25352->unwrapped_server;
      mono_field_set_value (D.25362, field, arg);
      <D.25363>:
      return;
      <D.25356>:
      <D.25351>:
      setter.198 = setter;
      if (setter.198 == 0B) goto <D.25365>; else goto <D.25366>;
      <D.25365>:
      D.25367 = mono_defaults.object_class;
      setter.199 = mono_class_get_method_from_name (D.25367, "FieldSetter", -1);
      setter = setter.199;
      setter.198 = setter;
      D.25369 = setter.198 == 0B;
      D.25370 = (long int) D.25369;
      D.25371 = __builtin_expect (D.25370, 0);
      if (D.25371 != 0) goto <D.25372>; else goto <D.25373>;
      <D.25372>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 6528, "setter");
      <D.25373>:
      <D.25366>:
      D.25374 = mono_defaults.mono_method_message_class;
      msg = mono_object_new (domain, D.25374);
      setter.198 = setter;
      D.25375 = mono_method_get_object (domain, setter.198, 0B);
      mono_message_init (domain, msg, D.25375, 0B);
      full_name = mono_type_get_full_name (klass);
      {
        void * * __p;

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

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

        D.25376 = msg->args;
        __p = mono_array_addr_with_size (D.25376, 8, 2);
        D.25376 = msg->args;
        mono_gc_wbarrier_set_arrayref (D.25376, __p, arg);
      }
      monoeg_g_free (full_name);
      D.25352 = tp->rp;
      mono_remoting_invoke (D.25352, msg, &exc, &out_args);
      exc.200 = exc;
      if (exc.200 != 0B) goto <D.25381>; else goto <D.25382>;
      <D.25381>:
      exc.200 = exc;
      mono_raise_exception (exc.200);
      <D.25382>:
    }
  finally
    {
      out_args = {CLOBBER};
      exc = {CLOBBER};
    }
}


mono_create_ftnptr (struct MonoDomain * domain, void * addr)
{
  void * D.25386;
  void * (*<T2548>) (struct MonoDomain *, void *) D.25387;

  D.25387 = callbacks.create_ftnptr;
  D.25386 = D.25387 (domain, addr);
  return D.25386;
}


mono_get_addr_from_ftnptr (void * descr)
{
  void * D.25389;
  void * (*<T14e7>) (void *) D.25390;

  D.25390 = callbacks.get_addr_from_ftnptr;
  D.25389 = D.25390 (descr);
  return D.25389;
}


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

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


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

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


mono_array_length (struct MonoArray * array)
{
  uintptr_t D.25396;
  unsigned int D.25397;

  D.25397 = array->max_length;
  D.25396 = (uintptr_t) D.25397;
  return D.25396;
}


mono_array_addr_with_size (struct MonoArray * array, int size, uintptr_t idx)
{
  char * D.25399;
  double[0:] * D.25400;
  long unsigned int D.25401;
  long unsigned int D.25402;

  D.25400 = &array->vector;
  D.25401 = (long unsigned int) size;
  D.25402 = D.25401 * idx;
  D.25399 = D.25400 + D.25402;
  return D.25399;
}