mono_runtime_object_init (struct MonoObject * this)
{
  struct MonoVTable * D.22962;
  char * D.22965;
  struct MonoClass * D.22966;
  unsigned char D.22967;
  unsigned char D.22968;
  struct MonoMethod * method;
  struct MonoClass * klass;

  method = 0B;
  D.22962 = this->vtable;
  klass = D.22962->klass;
  method = mono_class_get_method_from_name (klass, ".ctor", 0);
  if (method == 0B) goto <D.22963>; else goto <D.22964>;
  <D.22963>:
  D.22965 = mono_type_get_full_name (klass);
  monoeg_g_log (0B, 4, "Could not lookup zero argument constructor for class %s", D.22965);
  <D.21142>:
  goto <D.21142>;
  <D.22964>:
  D.22966 = method->klass;
  D.22967 = BIT_FIELD_REF <*D.22966, 8, 160>;
  D.22968 = D.22967 & 8;
  if (D.22968 != 0) goto <D.22969>; else goto <D.22970>;
  <D.22969>:
  this = mono_object_unbox (this);
  <D.22970>:
  mono_runtime_invoke (method, this, 0B, 0B);
}


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

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


mono_thread_get_main ()
{
  struct MonoThread * D.22977;

  D.22977 = main_thread;
  return D.22977;
}


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

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


mono_type_initialization_cleanup ()
{
  struct GHashTable * blocked_thread_hash.3;

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


free_main_args ()
{
  char * * main_args.4;
  unsigned int i.5;
  unsigned int D.22984;
  char * * D.22985;
  char * D.22986;
  int num_main_args.6;
  int i;

  i = 0;
  goto <D.22175>;
  <D.22174>:
  main_args.4 = main_args;
  i.5 = (unsigned int) i;
  D.22984 = i.5 * 4;
  D.22985 = main_args.4 + D.22984;
  D.22986 = *D.22985;
  monoeg_g_free (D.22986);
  i = i + 1;
  <D.22175>:
  num_main_args.6 = num_main_args;
  if (i < num_main_args.6) goto <D.22174>; else goto <D.22176>;
  <D.22176>:
  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.22988;
  unsigned char D.22989;
  struct MonoException * D.22992;
  struct MonoImage * D.22993;
  unsigned char D.22994;
  unsigned char D.22995;
  unsigned char D.22998;
  struct MonoDomain * D.23001;
  struct MonoException * exc.7;
  struct MonoException * exc.8;
  _Bool D.23012;
  long int D.23013;
  long int D.23014;
  _Bool D.23021;
  long int D.23022;
  long int D.23023;
  unsigned char D.23026;
  _Bool D.23031;
  long int D.23032;
  long int D.23033;
  struct MonoException * D.23038;
  struct GHashTable * type_initialization_hash.9;
  struct MonoDomain * D.23042;
  int D.23045;
  _Bool D.23050;
  long int D.23051;
  long int D.23052;
  struct MonoException * D.23057;
  struct CRITICAL_SECTION * D.23058;
  union mono_mutex_t * D.23059;
  _Bool D.23062;
  long int D.23063;
  long int D.23064;
  unsigned int D.23070;
  int D.23072;
  _Bool D.23075;
  long int D.23076;
  long int D.23077;
  unsigned int D.23080;
  int D.23083;
  _Bool D.23087;
  long int D.23088;
  long int D.23089;
  struct GHashTable * blocked_thread_hash.10;
  unsigned int D.23093;
  unsigned int D.23094;
  void * tid.11;
  _Bool D.23098;
  long int D.23099;
  long int D.23100;
  struct MonoImage * D.23109;
  int D.21217;
  int iftmp.12;
  int D.21216;
  const char[7] * D.23114;
  unsigned char D.23115;
  int D.23116;
  unsigned char D.23117;
  int D.23118;
  _Bool D.23119;
  _Bool D.23120;
  _Bool D.23121;
  const unsigned char * D.23124;
  unsigned char D.23125;
  int D.23126;
  const unsigned char * D.23127;
  unsigned char D.23128;
  int D.23129;
  _Bool D.23130;
  _Bool D.23131;
  const unsigned char * D.23134;
  unsigned char D.23135;
  int D.23136;
  const unsigned char * D.23137;
  unsigned char D.23138;
  int D.23139;
  _Bool D.23140;
  _Bool D.23141;
  const unsigned char * D.23144;
  unsigned char D.23145;
  int D.23146;
  const unsigned char * D.23147;
  unsigned char D.23148;
  int D.23149;
  const char * D.23151;
  int D.21226;
  int iftmp.13;
  int D.21225;
  const char[28] * D.23156;
  unsigned char D.23157;
  int D.23158;
  unsigned char D.23159;
  int D.23160;
  _Bool D.23161;
  _Bool D.23162;
  _Bool D.23163;
  const unsigned char * D.23166;
  unsigned char D.23167;
  int D.23168;
  const unsigned char * D.23169;
  unsigned char D.23170;
  int D.23171;
  _Bool D.23172;
  _Bool D.23173;
  const unsigned char * D.23176;
  unsigned char D.23177;
  int D.23178;
  const unsigned char * D.23179;
  unsigned char D.23180;
  int D.23181;
  _Bool D.23182;
  _Bool D.23183;
  const unsigned char * D.23186;
  unsigned char D.23187;
  int D.23188;
  const unsigned char * D.23189;
  unsigned char D.23190;
  int D.23191;
  const char * D.23193;
  char D.23197;
  union mono_mutex_t * D.23199;
  _Bool D.23202;
  long int D.23203;
  long int D.23204;
  struct MonoGHashTable * D.23207;
  struct MonoGHashTable * D.23210;
  _Bool D.23213;
  long int D.23214;
  long int D.23215;
  _Bool D.23222;
  long int D.23223;
  long int D.23224;
  _Bool D.23230;
  long int D.23231;
  long int D.23232;
  _Bool D.23237;
  long int D.23238;
  long int D.23239;
  _Bool D.23244;
  long int D.23245;
  long int D.23246;
  const void * tid.14;
  unsigned int D.23252;
  _Bool D.23259;
  long int D.23260;
  long int D.23261;
  struct MonoException * D.23268;
  struct MonoException * exc;
  struct MonoException * exc_to_throw;
  struct MonoMethod * method;
  struct MonoClass * klass;
  gchar * full_name;

  try
    {
      method = 0B;
      D.22988 = BIT_FIELD_REF <*vtable, 8, 184>;
      D.22989 = D.22988 & 2;
      if (D.22989 != 0) goto <D.22990>; else goto <D.22991>;
      <D.22990>:
      D.22992 = 0B;
      return D.22992;
      <D.22991>:
      exc = 0B;
      klass = vtable->klass;
      D.22993 = klass->image;
      D.22994 = BIT_FIELD_REF <*D.22993, 8, 128>;
      D.22995 = D.22994 & 64;
      if (D.22995 == 0) goto <D.22996>; else goto <D.22997>;
      <D.22996>:
      D.22993 = klass->image;
      mono_image_check_for_module_cctor (D.22993);
      D.22993 = klass->image;
      D.22994 = BIT_FIELD_REF <*D.22993, 8, 128>;
      D.22998 = D.22994 & 128;
      if (D.22998 != 0) goto <D.22999>; else goto <D.23000>;
      <D.22999>:
      {
        struct MonoClass * module_klass;
        struct MonoVTable * module_vtable;

        D.22993 = klass->image;
        module_klass = mono_class_get (D.22993, 33554433);
        D.23001 = vtable->domain;
        module_vtable = mono_class_vtable_full (D.23001, module_klass, raise_exception);
        if (module_vtable == 0B) goto <D.23002>; else goto <D.23003>;
        <D.23002>:
        D.22992 = 0B;
        return D.22992;
        <D.23003>:
        exc.7 = mono_runtime_class_init_full (module_vtable, raise_exception);
        exc = exc.7;
        exc.8 = exc;
        if (exc.8 != 0B) goto <D.23006>; else goto <D.23007>;
        <D.23006>:
        D.22992 = exc;
        return D.22992;
        <D.23007>:
      }
      <D.23000>:
      <D.22997>:
      method = mono_class_get_cctor (klass);
      if (method != 0B) goto <D.23008>; else goto <D.23009>;
      <D.23008>:
      {
        struct MonoDomain * domain;
        struct TypeInitializationLock * lock;
        guint32 tid;
        int do_initialization;
        struct MonoDomain * last_domain;

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

          ret = pthread_mutex_lock (&type_initialization_section.mutex);
          if (ret != 0) goto <D.23010>; else goto <D.23011>;
          <D.23010>:
          monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
          <D.23011>:
          D.23012 = ret != 0;
          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", 308, "ret == 0");
          <D.23016>:
        }
        D.22988 = BIT_FIELD_REF <*vtable, 8, 184>;
        D.22989 = D.22988 & 2;
        if (D.22989 != 0) goto <D.23017>; else goto <D.23018>;
        <D.23017>:
        {
          int ret;

          ret = pthread_mutex_unlock (&type_initialization_section.mutex);
          if (ret != 0) goto <D.23019>; else goto <D.23020>;
          <D.23019>:
          monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
          <D.23020>:
          D.23021 = ret != 0;
          D.23022 = (long int) D.23021;
          D.23023 = __builtin_expect (D.23022, 0);
          if (D.23023 != 0) goto <D.23024>; else goto <D.23025>;
          <D.23024>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 311, "ret == 0");
          <D.23025>:
        }
        D.22992 = 0B;
        return D.22992;
        <D.23018>:
        D.22988 = BIT_FIELD_REF <*vtable, 8, 184>;
        D.23026 = D.22988 & 4;
        if (D.23026 != 0) goto <D.23027>; else goto <D.23028>;
        <D.23027>:
        {
          int ret;

          ret = pthread_mutex_unlock (&type_initialization_section.mutex);
          if (ret != 0) goto <D.23029>; else goto <D.23030>;
          <D.23029>:
          monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
          <D.23030>:
          D.23031 = ret != 0;
          D.23032 = (long int) D.23031;
          D.23033 = __builtin_expect (D.23032, 0);
          if (D.23033 != 0) goto <D.23034>; else goto <D.23035>;
          <D.23034>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 315, "ret == 0");
          <D.23035>:
        }
        if (raise_exception != 0) goto <D.23036>; else goto <D.23037>;
        <D.23036>:
        D.23038 = get_type_init_exception_for_vtable (vtable);
        mono_raise_exception (D.23038);
        <D.23037>:
        D.22992 = get_type_init_exception_for_vtable (vtable);
        return D.22992;
        <D.23028>:
        type_initialization_hash.9 = type_initialization_hash;
        lock = monoeg_g_hash_table_lookup (type_initialization_hash.9, vtable);
        if (lock == 0B) goto <D.23040>; else goto <D.23041>;
        <D.23040>:
        D.23042 = mono_domain_get ();
        if (D.23042 != domain) goto <D.23043>; else goto <D.23044>;
        <D.23043>:
        last_domain = mono_domain_get ();
        D.23045 = mono_domain_set (domain, 0);
        if (D.23045 == 0) goto <D.23046>; else goto <D.23047>;
        <D.23046>:
        vtable->initialized = 1;
        {
          int ret;

          ret = pthread_mutex_unlock (&type_initialization_section.mutex);
          if (ret != 0) goto <D.23048>; else goto <D.23049>;
          <D.23048>:
          monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
          <D.23049>:
          D.23050 = ret != 0;
          D.23051 = (long int) D.23050;
          D.23052 = __builtin_expect (D.23051, 0);
          if (D.23052 != 0) goto <D.23053>; else goto <D.23054>;
          <D.23053>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 330, "ret == 0");
          <D.23054>:
        }
        if (raise_exception != 0) goto <D.23055>; else goto <D.23056>;
        <D.23055>:
        D.23057 = mono_get_exception_appdomain_unloaded ();
        mono_raise_exception (D.23057);
        <D.23056>:
        D.22992 = mono_get_exception_appdomain_unloaded ();
        return D.22992;
        <D.23047>:
        <D.23044>:
        lock = monoeg_malloc (40);
        D.23058 = &lock->initialization_section;
        InitializeCriticalSection (D.23058);
        lock->initializing_tid = tid;
        lock->waiting_count = 1;
        lock->done = 0;
        {
          int ret;

          D.23059 = &lock->initialization_section.mutex;
          ret = pthread_mutex_lock (D.23059);
          if (ret != 0) goto <D.23060>; else goto <D.23061>;
          <D.23060>:
          monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
          <D.23061>:
          D.23062 = ret != 0;
          D.23063 = (long int) D.23062;
          D.23064 = __builtin_expect (D.23063, 0);
          if (D.23064 != 0) goto <D.23065>; else goto <D.23066>;
          <D.23065>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 342, "ret == 0");
          <D.23066>:
        }
        type_initialization_hash.9 = type_initialization_hash;
        monoeg_g_hash_table_insert_replace (type_initialization_hash.9, vtable, lock, 0);
        do_initialization = 1;
        goto <D.23067>;
        <D.23041>:
        {
          void * blocked;
          struct TypeInitializationLock * pending_lock;

          D.23070 = lock->initializing_tid;
          if (D.23070 == tid) goto <D.23068>; else goto <D.23071>;
          <D.23071>:
          D.23072 = lock->done;
          if (D.23072 != 0) goto <D.23068>; else goto <D.23069>;
          <D.23068>:
          {
            int ret;

            ret = pthread_mutex_unlock (&type_initialization_section.mutex);
            if (ret != 0) goto <D.23073>; else goto <D.23074>;
            <D.23073>:
            monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
            <D.23074>:
            D.23075 = ret != 0;
            D.23076 = (long int) D.23075;
            D.23077 = __builtin_expect (D.23076, 0);
            if (D.23077 != 0) goto <D.23078>; else goto <D.23079>;
            <D.23078>:
            monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 350, "ret == 0");
            <D.23079>:
          }
          D.22992 = 0B;
          return D.22992;
          <D.23069>:
          D.23070 = lock->initializing_tid;
          blocked = (void *) D.23070;
          goto <D.21207>;
          <D.21206>:
          D.23080 = pending_lock->initializing_tid;
          if (D.23080 == tid) goto <D.23081>; else goto <D.23082>;
          <D.23081>:
          D.23083 = pending_lock->done;
          if (D.23083 == 0) goto <D.23084>; else goto <D.21205>;
          <D.23084>:
          {
            int ret;

            ret = pthread_mutex_unlock (&type_initialization_section.mutex);
            if (ret != 0) goto <D.23085>; else goto <D.23086>;
            <D.23085>:
            monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
            <D.23086>:
            D.23087 = ret != 0;
            D.23088 = (long int) D.23087;
            D.23089 = __builtin_expect (D.23088, 0);
            if (D.23089 != 0) goto <D.23090>; else goto <D.23091>;
            <D.23090>:
            monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 358, "ret == 0");
            <D.23091>:
          }
          D.22992 = 0B;
          return D.22992;
          <D.23082>:
          D.23080 = pending_lock->initializing_tid;
          blocked = (void *) D.23080;
          <D.21207>:
          blocked_thread_hash.10 = blocked_thread_hash;
          pending_lock = monoeg_g_hash_table_lookup (blocked_thread_hash.10, blocked);
          if (pending_lock != 0B) goto <D.21206>; else goto <D.21205>;
          <D.21205>:
          D.23093 = lock->waiting_count;
          D.23094 = D.23093 + 1;
          lock->waiting_count = D.23094;
          blocked_thread_hash.10 = blocked_thread_hash;
          tid.11 = (void *) tid;
          monoeg_g_hash_table_insert_replace (blocked_thread_hash.10, tid.11, lock, 0);
        }
        <D.23067>:
        {
          int ret;

          ret = pthread_mutex_unlock (&type_initialization_section.mutex);
          if (ret != 0) goto <D.23096>; else goto <D.23097>;
          <D.23096>:
          monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
          <D.23097>:
          D.23098 = ret != 0;
          D.23099 = (long int) D.23098;
          D.23100 = __builtin_expect (D.23099, 0);
          if (D.23100 != 0) goto <D.23101>; else goto <D.23102>;
          <D.23101>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 373, "ret == 0");
          <D.23102>:
        }
        if (do_initialization != 0) goto <D.23103>; else goto <D.23104>;
        <D.23103>:
        mono_runtime_invoke (method, 0B, 0B, &exc);
        exc.8 = exc;
        if (exc.8 != 0B) goto <D.23107>; else goto <D.23108>;
        <D.23107>:
        D.22993 = klass->image;
        D.23109 = mono_defaults.corlib;
        if (D.22993 != D.23109) goto <D.23105>; else goto <D.23110>;
        <D.23110>:
        {
          size_t __s1_len;
          size_t __s2_len;

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

            __s2 = klass->name_space;
            D.23114 = "System";
            D.23115 = MEM[(const unsigned char *)D.23114];
            D.23116 = (int) D.23115;
            D.23117 = *__s2;
            D.23118 = (int) D.23117;
            __result = D.23116 - D.23118;
            {
              D.23119 = __s2_len != 0;
              D.23120 = __result == 0;
              D.23121 = D.23119 & D.23120;
              if (D.23121 != 0) goto <D.23122>; else goto <D.23123>;
              <D.23122>:
              D.23124 = &MEM[(void *)"System" + 1B];
              D.23125 = *D.23124;
              D.23126 = (int) D.23125;
              D.23127 = __s2 + 1;
              D.23128 = *D.23127;
              D.23129 = (int) D.23128;
              __result = D.23126 - D.23129;
              D.23130 = __s2_len > 1;
              D.23120 = __result == 0;
              D.23131 = D.23130 & D.23120;
              if (D.23131 != 0) goto <D.23132>; else goto <D.23133>;
              <D.23132>:
              D.23134 = &MEM[(void *)"System" + 2B];
              D.23135 = *D.23134;
              D.23136 = (int) D.23135;
              D.23137 = __s2 + 2;
              D.23138 = *D.23137;
              D.23139 = (int) D.23138;
              __result = D.23136 - D.23139;
              D.23140 = __s2_len > 2;
              D.23120 = __result == 0;
              D.23141 = D.23140 & D.23120;
              if (D.23141 != 0) goto <D.23142>; else goto <D.23143>;
              <D.23142>:
              D.23144 = &MEM[(void *)"System" + 3B];
              D.23145 = *D.23144;
              D.23146 = (int) D.23145;
              D.23147 = __s2 + 3;
              D.23148 = *D.23147;
              D.23149 = (int) D.23148;
              __result = D.23146 - D.23149;
              <D.23143>:
              <D.23133>:
              <D.23123>:
            }
            D.21216 = __result;
          }
          iftmp.12 = -D.21216;
          goto <D.23150>;
          <D.23113>:
          D.23151 = klass->name_space;
          iftmp.12 = __builtin_strcmp (D.23151, "System");
          <D.23150>:
          D.21217 = iftmp.12;
        }
        if (D.21217 != 0) goto <D.23105>; else goto <D.23152>;
        <D.23152>:
        {
          size_t __s1_len;
          size_t __s2_len;

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

            __s2 = klass->name;
            D.23156 = "TypeInitializationException";
            D.23157 = MEM[(const unsigned char *)D.23156];
            D.23158 = (int) D.23157;
            D.23159 = *__s2;
            D.23160 = (int) D.23159;
            __result = D.23158 - D.23160;
            {
              D.23161 = __s2_len != 0;
              D.23162 = __result == 0;
              D.23163 = D.23161 & D.23162;
              if (D.23163 != 0) goto <D.23164>; else goto <D.23165>;
              <D.23164>:
              D.23166 = &MEM[(void *)"TypeInitializationException" + 1B];
              D.23167 = *D.23166;
              D.23168 = (int) D.23167;
              D.23169 = __s2 + 1;
              D.23170 = *D.23169;
              D.23171 = (int) D.23170;
              __result = D.23168 - D.23171;
              D.23172 = __s2_len > 1;
              D.23162 = __result == 0;
              D.23173 = D.23172 & D.23162;
              if (D.23173 != 0) goto <D.23174>; else goto <D.23175>;
              <D.23174>:
              D.23176 = &MEM[(void *)"TypeInitializationException" + 2B];
              D.23177 = *D.23176;
              D.23178 = (int) D.23177;
              D.23179 = __s2 + 2;
              D.23180 = *D.23179;
              D.23181 = (int) D.23180;
              __result = D.23178 - D.23181;
              D.23182 = __s2_len > 2;
              D.23162 = __result == 0;
              D.23183 = D.23182 & D.23162;
              if (D.23183 != 0) goto <D.23184>; else goto <D.23185>;
              <D.23184>:
              D.23186 = &MEM[(void *)"TypeInitializationException" + 3B];
              D.23187 = *D.23186;
              D.23188 = (int) D.23187;
              D.23189 = __s2 + 3;
              D.23190 = *D.23189;
              D.23191 = (int) D.23190;
              __result = D.23188 - D.23191;
              <D.23185>:
              <D.23175>:
              <D.23165>:
            }
            D.21225 = __result;
          }
          iftmp.13 = -D.21225;
          goto <D.23192>;
          <D.23155>:
          D.23193 = klass->name;
          iftmp.13 = __builtin_strcmp (D.23193, "TypeInitializationException");
          <D.23192>:
          D.21226 = iftmp.13;
        }
        if (D.21226 != 0) goto <D.23105>; else goto <D.23106>;
        <D.23105>:
        vtable->init_failed = 1;
        D.23151 = klass->name_space;
        if (D.23151 != 0B) goto <D.23196>; else goto <D.23194>;
        <D.23196>:
        D.23151 = klass->name_space;
        D.23197 = *D.23151;
        if (D.23197 != 0) goto <D.23198>; else goto <D.23194>;
        <D.23198>:
        D.23151 = klass->name_space;
        D.23193 = klass->name;
        full_name = monoeg_g_strdup_printf ("%s.%s", D.23151, D.23193);
        goto <D.23195>;
        <D.23194>:
        D.23193 = klass->name;
        full_name = monoeg_strdup (D.23193);
        <D.23195>:
        exc.8 = exc;
        exc_to_throw = mono_get_exception_type_initialization (full_name, exc.8);
        monoeg_g_free (full_name);
        {
          int ret;

          D.23199 = &domain->lock.mutex;
          ret = pthread_mutex_lock (D.23199);
          if (ret != 0) goto <D.23200>; else goto <D.23201>;
          <D.23200>:
          monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
          <D.23201>:
          D.23202 = ret != 0;
          D.23203 = (long int) D.23202;
          D.23204 = __builtin_expect (D.23203, 0);
          if (D.23204 != 0) goto <D.23205>; else goto <D.23206>;
          <D.23205>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 397, "ret == 0");
          <D.23206>:
        }
        D.23207 = domain->type_init_exception_hash;
        if (D.23207 == 0B) goto <D.23208>; else goto <D.23209>;
        <D.23208>:
        D.23210 = mono_g_hash_table_new_type (mono_aligned_addr_hash, 0B, 2);
        domain->type_init_exception_hash = D.23210;
        <D.23209>:
        D.23207 = domain->type_init_exception_hash;
        mono_g_hash_table_insert (D.23207, klass, exc_to_throw);
        {
          int ret;

          D.23199 = &domain->lock.mutex;
          ret = pthread_mutex_unlock (D.23199);
          if (ret != 0) goto <D.23211>; else goto <D.23212>;
          <D.23211>:
          monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
          <D.23212>:
          D.23213 = ret != 0;
          D.23214 = (long int) D.23213;
          D.23215 = __builtin_expect (D.23214, 0);
          if (D.23215 != 0) goto <D.23216>; else goto <D.23217>;
          <D.23216>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 401, "ret == 0");
          <D.23217>:
        }
        <D.23106>:
        <D.23108>:
        if (last_domain != 0B) goto <D.23218>; else goto <D.23219>;
        <D.23218>:
        mono_domain_set (last_domain, 1);
        <D.23219>:
        lock->done = 1;
        {
          int ret;

          D.23059 = &lock->initialization_section.mutex;
          ret = pthread_mutex_unlock (D.23059);
          if (ret != 0) goto <D.23220>; else goto <D.23221>;
          <D.23220>:
          monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
          <D.23221>:
          D.23222 = ret != 0;
          D.23223 = (long int) D.23222;
          D.23224 = __builtin_expect (D.23223, 0);
          if (D.23224 != 0) goto <D.23225>; else goto <D.23226>;
          <D.23225>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 407, "ret == 0");
          <D.23226>:
        }
        goto <D.23227>;
        <D.23104>:
        {
          int ret;

          D.23059 = &lock->initialization_section.mutex;
          ret = pthread_mutex_lock (D.23059);
          if (ret != 0) goto <D.23228>; else goto <D.23229>;
          <D.23228>:
          monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
          <D.23229>:
          D.23230 = ret != 0;
          D.23231 = (long int) D.23230;
          D.23232 = __builtin_expect (D.23231, 0);
          if (D.23232 != 0) goto <D.23233>; else goto <D.23234>;
          <D.23233>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 410, "ret == 0");
          <D.23234>:
        }
        {
          int ret;

          D.23059 = &lock->initialization_section.mutex;
          ret = pthread_mutex_unlock (D.23059);
          if (ret != 0) goto <D.23235>; else goto <D.23236>;
          <D.23235>:
          monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
          <D.23236>:
          D.23237 = ret != 0;
          D.23238 = (long int) D.23237;
          D.23239 = __builtin_expect (D.23238, 0);
          if (D.23239 != 0) goto <D.23240>; else goto <D.23241>;
          <D.23240>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 411, "ret == 0");
          <D.23241>:
        }
        <D.23227>:
        {
          int ret;

          ret = pthread_mutex_lock (&type_initialization_section.mutex);
          if (ret != 0) goto <D.23242>; else goto <D.23243>;
          <D.23242>:
          monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
          <D.23243>:
          D.23244 = ret != 0;
          D.23245 = (long int) D.23244;
          D.23246 = __builtin_expect (D.23245, 0);
          if (D.23246 != 0) goto <D.23247>; else goto <D.23248>;
          <D.23247>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 414, "ret == 0");
          <D.23248>:
        }
        D.23070 = lock->initializing_tid;
        if (D.23070 != tid) goto <D.23249>; else goto <D.23250>;
        <D.23249>:
        blocked_thread_hash.10 = blocked_thread_hash;
        tid.14 = (const void *) tid;
        monoeg_g_hash_table_remove (blocked_thread_hash.10, tid.14);
        <D.23250>:
        D.23093 = lock->waiting_count;
        D.23252 = D.23093 + 4294967295;
        lock->waiting_count = D.23252;
        D.23093 = lock->waiting_count;
        if (D.23093 == 0) goto <D.23253>; else goto <D.23254>;
        <D.23253>:
        D.23058 = &lock->initialization_section;
        DeleteCriticalSection (D.23058);
        type_initialization_hash.9 = type_initialization_hash;
        monoeg_g_hash_table_remove (type_initialization_hash.9, vtable);
        monoeg_g_free (lock);
        <D.23254>:
        mono_memory_barrier ();
        D.22988 = BIT_FIELD_REF <*vtable, 8, 184>;
        D.23026 = D.22988 & 4;
        if (D.23026 == 0) goto <D.23255>; else goto <D.23256>;
        <D.23255>:
        vtable->initialized = 1;
        <D.23256>:
        {
          int ret;

          ret = pthread_mutex_unlock (&type_initialization_section.mutex);
          if (ret != 0) goto <D.23257>; else goto <D.23258>;
          <D.23257>:
          monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
          <D.23258>:
          D.23259 = ret != 0;
          D.23260 = (long int) D.23259;
          D.23261 = __builtin_expect (D.23260, 0);
          if (D.23261 != 0) goto <D.23262>; else goto <D.23263>;
          <D.23262>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 426, "ret == 0");
          <D.23263>:
        }
        D.22988 = BIT_FIELD_REF <*vtable, 8, 184>;
        D.23026 = D.22988 & 4;
        if (D.23026 != 0) goto <D.23264>; else goto <D.23265>;
        <D.23264>:
        if (raise_exception != 0) goto <D.23266>; else goto <D.23267>;
        <D.23266>:
        D.23268 = get_type_init_exception_for_vtable (vtable);
        mono_raise_exception (D.23268);
        <D.23267>:
        D.22992 = get_type_init_exception_for_vtable (vtable);
        return D.22992;
        <D.23265>:
      }
      goto <D.23269>;
      <D.23009>:
      vtable->initialized = 1;
      D.22992 = 0B;
      return D.22992;
      <D.23269>:
      D.22992 = 0B;
      return D.22992;
    }
  finally
    {
      exc = {CLOBBER};
    }
}


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

  if (str != 0B) goto <D.23272>; else goto <D.23273>;
  <D.23272>:
  D.23274 = __strdup (str);
  return D.23274;
  <D.23273>:
  D.23274 = 0B;
  return D.23274;
}


mono_memory_barrier ()
{
  __sync_synchronize ();
}


get_type_init_exception_for_vtable (struct MonoVTable * vtable)
{
  unsigned char D.23276;
  unsigned char D.23277;
  char * D.23280;
  union mono_mutex_t * D.23281;
  _Bool D.23284;
  long int D.23285;
  long int D.23286;
  struct MonoGHashTable * D.23289;
  _Bool D.23294;
  long int D.23295;
  long int D.23296;
  const char * D.23303;
  char D.23305;
  const char * D.23307;
  struct MonoException * D.23308;
  struct MonoDomain * domain;
  struct MonoClass * klass;
  struct MonoException * ex;
  gchar * full_name;

  domain = vtable->domain;
  klass = vtable->klass;
  D.23276 = BIT_FIELD_REF <*vtable, 8, 184>;
  D.23277 = D.23276 & 4;
  if (D.23277 == 0) goto <D.23278>; else goto <D.23279>;
  <D.23278>:
  D.23280 = 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.23280);
  <D.21174>:
  goto <D.21174>;
  <D.23279>:
  ex = 0B;
  {
    int ret;

    D.23281 = &domain->lock.mutex;
    ret = pthread_mutex_lock (D.23281);
    if (ret != 0) goto <D.23282>; else goto <D.23283>;
    <D.23282>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
    <D.23283>:
    D.23284 = ret != 0;
    D.23285 = (long int) D.23284;
    D.23286 = __builtin_expect (D.23285, 0);
    if (D.23286 != 0) goto <D.23287>; else goto <D.23288>;
    <D.23287>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 236, "ret == 0");
    <D.23288>:
  }
  D.23289 = domain->type_init_exception_hash;
  if (D.23289 != 0B) goto <D.23290>; else goto <D.23291>;
  <D.23290>:
  D.23289 = domain->type_init_exception_hash;
  ex = mono_g_hash_table_lookup (D.23289, klass);
  <D.23291>:
  {
    int ret;

    D.23281 = &domain->lock.mutex;
    ret = pthread_mutex_unlock (D.23281);
    if (ret != 0) goto <D.23292>; else goto <D.23293>;
    <D.23292>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.23293>:
    D.23294 = ret != 0;
    D.23295 = (long int) D.23294;
    D.23296 = __builtin_expect (D.23295, 0);
    if (D.23296 != 0) goto <D.23297>; else goto <D.23298>;
    <D.23297>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 239, "ret == 0");
    <D.23298>:
  }
  if (ex == 0B) goto <D.23299>; else goto <D.23300>;
  <D.23299>:
  D.23303 = klass->name_space;
  if (D.23303 != 0B) goto <D.23304>; else goto <D.23301>;
  <D.23304>:
  D.23303 = klass->name_space;
  D.23305 = *D.23303;
  if (D.23305 != 0) goto <D.23306>; else goto <D.23301>;
  <D.23306>:
  D.23303 = klass->name_space;
  D.23307 = klass->name;
  full_name = monoeg_g_strdup_printf ("%s.%s", D.23303, D.23307);
  goto <D.23302>;
  <D.23301>:
  D.23307 = klass->name;
  full_name = monoeg_strdup (D.23307);
  <D.23302>:
  ex = mono_get_exception_type_initialization (full_name, 0B);
  monoeg_g_free (full_name);
  <D.23300>:
  D.23308 = ex;
  return D.23308;
}


mono_release_type_locks (struct MonoInternalThread * thread)
{
  _Bool D.23312;
  long int D.23313;
  long int D.23314;
  struct GHashTable * type_initialization_hash.15;
  long long unsigned int D.23318;
  unsigned int D.23319;
  void * D.23320;
  _Bool D.23323;
  long int D.23324;
  long int D.23325;

  {
    int ret;

    ret = pthread_mutex_lock (&type_initialization_section.mutex);
    if (ret != 0) goto <D.23310>; else goto <D.23311>;
    <D.23310>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
    <D.23311>:
    D.23312 = ret != 0;
    D.23313 = (long int) D.23312;
    D.23314 = __builtin_expect (D.23313, 0);
    if (D.23314 != 0) goto <D.23315>; else goto <D.23316>;
    <D.23315>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 469, "ret == 0");
    <D.23316>:
  }
  type_initialization_hash.15 = type_initialization_hash;
  D.23318 = thread->tid;
  D.23319 = (unsigned int) D.23318;
  D.23320 = (void *) D.23319;
  monoeg_g_hash_table_foreach_remove (type_initialization_hash.15, release_type_locks, D.23320);
  {
    int ret;

    ret = pthread_mutex_unlock (&type_initialization_section.mutex);
    if (ret != 0) goto <D.23321>; else goto <D.23322>;
    <D.23321>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.23322>:
    D.23323 = ret != 0;
    D.23324 = (long int) D.23323;
    D.23325 = __builtin_expect (D.23324, 0);
    if (D.23325 != 0) goto <D.23326>; else goto <D.23327>;
    <D.23326>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 471, "ret == 0");
    <D.23327>:
  }
}


release_type_locks (void * key, void * value, void * user)
{
  unsigned int D.23328;
  unsigned int user.16;
  int D.23332;
  union mono_mutex_t * D.23335;
  _Bool D.23338;
  long int D.23339;
  long int D.23340;
  unsigned int D.23343;
  unsigned int D.23344;
  struct CRITICAL_SECTION * D.23347;
  gboolean D.23348;
  struct MonoVTable * vtable;
  struct TypeInitializationLock * lock;

  vtable = key;
  lock = value;
  D.23328 = lock->initializing_tid;
  user.16 = (unsigned int) user;
  if (D.23328 == user.16) goto <D.23330>; else goto <D.23331>;
  <D.23330>:
  D.23332 = lock->done;
  if (D.23332 == 0) goto <D.23333>; else goto <D.23334>;
  <D.23333>:
  lock->done = 1;
  vtable->init_failed = 1;
  {
    int ret;

    D.23335 = &lock->initialization_section.mutex;
    ret = pthread_mutex_unlock (D.23335);
    if (ret != 0) goto <D.23336>; else goto <D.23337>;
    <D.23336>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.23337>:
    D.23338 = ret != 0;
    D.23339 = (long int) D.23338;
    D.23340 = __builtin_expect (D.23339, 0);
    if (D.23340 != 0) goto <D.23341>; else goto <D.23342>;
    <D.23341>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 455, "ret == 0");
    <D.23342>:
  }
  D.23343 = lock->waiting_count;
  D.23344 = D.23343 + 4294967295;
  lock->waiting_count = D.23344;
  D.23343 = lock->waiting_count;
  if (D.23343 == 0) goto <D.23345>; else goto <D.23346>;
  <D.23345>:
  D.23347 = &lock->initialization_section;
  DeleteCriticalSection (D.23347);
  monoeg_g_free (lock);
  D.23348 = 1;
  return D.23348;
  <D.23346>:
  <D.23334>:
  <D.23331>:
  D.23348 = 0;
  return D.23348;
}


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


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

  D.23351 = __builtin_object_size (__dest, 0);
  D.23350 = __builtin___memcpy_chk (__dest, __src, __len, D.23351);
  return D.23350;
}


mono_get_runtime_callbacks ()
{
  struct MonoRuntimeCallbacks * D.23353;

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


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

  if (func != 0B) goto <D.23356>; else goto <D.23357>;
  <D.23356>:
  iftmp.17 = func;
  goto <D.23358>;
  <D.23357>:
  iftmp.17 = default_trampoline;
  <D.23358>:
  arch_create_jit_trampoline = iftmp.17;
}


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

  D.23359 = method;
  return D.23359;
}


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

  if (func != 0B) goto <D.23362>; else goto <D.23363>;
  <D.23362>:
  iftmp.18 = func;
  goto <D.23364>;
  <D.23363>:
  iftmp.18 = default_jump_trampoline;
  <D.23364>:
  arch_create_jump_trampoline = iftmp.18;
}


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

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


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

  if (func != 0B) goto <D.23368>; else goto <D.23369>;
  <D.23368>:
  iftmp.19 = func;
  goto <D.23370>;
  <D.23369>:
  iftmp.19 = default_remoting_trampoline;
  <D.23370>:
  arch_create_remoting_trampoline = iftmp.19;
}


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

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


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

  if (func != 0B) goto <D.23374>; else goto <D.23375>;
  <D.23374>:
  iftmp.20 = func;
  goto <D.23376>;
  <D.23375>:
  iftmp.20 = default_delegate_trampoline;
  <D.23376>:
  arch_create_delegate_trampoline = iftmp.20;
}


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

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


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

  default_mono_compile_method.21 = default_mono_compile_method;
  if (default_mono_compile_method.21 == 0B) goto <D.23380>; else goto <D.23381>;
  <D.23380>:
  monoeg_g_log (0B, 4, "compile method called on uninitialized runtime");
  <D.21298>:
  goto <D.21298>;
  D.23382 = 0B;
  return D.23382;
  <D.23381>:
  default_mono_compile_method.21 = default_mono_compile_method;
  D.23382 = default_mono_compile_method.21 (method);
  return D.23382;
}


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

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


mono_runtime_create_delegate_trampoline (struct MonoClass * klass)
{
  void * D.23387;
  void * (*<T27a4>) (struct MonoDomain *, struct MonoClass *) arch_create_delegate_trampoline.23;
  struct MonoDomain * D.23389;

  arch_create_delegate_trampoline.23 = arch_create_delegate_trampoline;
  D.23389 = mono_domain_get ();
  D.23387 = arch_create_delegate_trampoline.23 (D.23389, klass);
  return D.23387;
}


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

  default_mono_free_method.24 = default_mono_free_method;
  if (default_mono_free_method.24 != 0B) goto <D.23392>; else goto <D.23393>;
  <D.23392>:
  default_mono_free_method.24 = default_mono_free_method;
  default_mono_free_method.24 (domain, method);
  <D.23393>:
  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.23394;

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


compute_class_bitmap (struct MonoClass * class, gsize * bitmap, int size, int offset, int * max_set, gboolean static_fields)
{
  int D.23398;
  unsigned int D.23399;
  unsigned int D.23400;
  int D.23402;
  unsigned int D.23403;
  unsigned int D.23404;
  _Bool D.23407;
  long int D.23408;
  long int D.23409;
  unsigned int max_size.25;
  unsigned int D.23413;
  unsigned int D.23414;
  unsigned int D.23415;
  struct MonoImage * D.23418;
  struct MonoImage * D.23419;
  int D.21335;
  int iftmp.26;
  int D.21331;
  const char[10] * D.23425;
  unsigned char D.23426;
  int D.23427;
  unsigned char D.23428;
  int D.23429;
  _Bool D.23430;
  _Bool D.23431;
  _Bool D.23432;
  const unsigned char * D.23435;
  unsigned char D.23436;
  int D.23437;
  const unsigned char * D.23438;
  unsigned char D.23439;
  int D.23440;
  _Bool D.23441;
  _Bool D.23442;
  const unsigned char * D.23445;
  unsigned char D.23446;
  int D.23447;
  const unsigned char * D.23448;
  unsigned char D.23449;
  int D.23450;
  _Bool D.23451;
  _Bool D.23452;
  const unsigned char * D.23455;
  unsigned char D.23456;
  int D.23457;
  const unsigned char * D.23458;
  unsigned char D.23459;
  int D.23460;
  const char * D.23462;
  int D.23465;
  unsigned int D.23466;
  gsize * D.23467;
  struct MonoType * D.23470;
  short unsigned int D.23471;
  int D.23472;
  int D.23473;
  int D.23476;
  unsigned char D.23482;
  unsigned char D.23483;
  int D.23487;
  unsigned int D.23490;
  unsigned int offset.27;
  unsigned char D.23492;
  int D.23493;
  unsigned int D.23494;
  _Bool D.23495;
  long int D.23496;
  long int D.23497;
  unsigned int size.28;
  _Bool D.23501;
  unsigned int max_size.29;
  _Bool D.23503;
  _Bool D.23504;
  int D.23505;
  _Bool D.23506;
  long int D.23507;
  long int D.23508;
  unsigned int D.23511;
  unsigned int D.23512;
  gsize * D.23513;
  unsigned int D.23514;
  int pos.30;
  int D.23516;
  unsigned int D.23517;
  unsigned int D.23518;
  int D.23519;
  unsigned int D.23520;
  unsigned int D.23521;
  int D.23522;
  int D.23523;
  unsigned int D.23528;
  unsigned int D.23529;
  gsize * D.23530;
  unsigned int D.23531;
  unsigned int D.23532;
  unsigned char D.23533;
  unsigned char D.23534;
  unsigned int D.23537;
  int D.23538;
  struct MonoClass * D.23539;
  char * D.23540;
  const char * D.23541;
  struct MonoClassField * field;
  struct MonoClass * p;
  guint32 pos;
  int max_size;

  if (static_fields != 0) goto <D.23396>; else goto <D.23397>;
  <D.23396>:
  D.23398 = mono_class_data_size (class);
  D.23399 = (unsigned int) D.23398;
  D.23400 = D.23399 / 4;
  max_size = (int) D.23400;
  goto <D.23401>;
  <D.23397>:
  D.23402 = class->instance_size;
  D.23403 = (unsigned int) D.23402;
  D.23404 = D.23403 / 4;
  max_size = (int) D.23404;
  <D.23401>:
  if (max_size > size) goto <D.23405>; else goto <D.23406>;
  <D.23405>:
  D.23407 = offset > 0;
  D.23408 = (long int) D.23407;
  D.23409 = __builtin_expect (D.23408, 0);
  if (D.23409 != 0) goto <D.23410>; else goto <D.23411>;
  <D.23410>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 664, "offset <= 0");
  <D.23411>:
  max_size.25 = (unsigned int) max_size;
  D.23413 = max_size.25 + 31;
  D.23414 = D.23413 / 32;
  D.23415 = D.23414 * 4;
  bitmap = monoeg_malloc0 (D.23415);
  size = max_size;
  <D.23406>:
  if (static_fields == 0) goto <D.23416>; else goto <D.23417>;
  <D.23416>:
  D.23418 = class->image;
  D.23419 = mono_defaults.corlib;
  if (D.23418 == D.23419) goto <D.23420>; else goto <D.23421>;
  <D.23420>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = class->name;
      D.23425 = "Ephemeron";
      D.23426 = MEM[(const unsigned char *)D.23425];
      D.23427 = (int) D.23426;
      D.23428 = *__s2;
      D.23429 = (int) D.23428;
      __result = D.23427 - D.23429;
      {
        D.23430 = __s1_len != 0;
        D.23431 = __result == 0;
        D.23432 = D.23430 & D.23431;
        if (D.23432 != 0) goto <D.23433>; else goto <D.23434>;
        <D.23433>:
        D.23435 = &MEM[(void *)"Ephemeron" + 1B];
        D.23436 = *D.23435;
        D.23437 = (int) D.23436;
        D.23438 = __s2 + 1;
        D.23439 = *D.23438;
        D.23440 = (int) D.23439;
        __result = D.23437 - D.23440;
        D.23441 = __s1_len > 1;
        D.23431 = __result == 0;
        D.23442 = D.23441 & D.23431;
        if (D.23442 != 0) goto <D.23443>; else goto <D.23444>;
        <D.23443>:
        D.23445 = &MEM[(void *)"Ephemeron" + 2B];
        D.23446 = *D.23445;
        D.23447 = (int) D.23446;
        D.23448 = __s2 + 2;
        D.23449 = *D.23448;
        D.23450 = (int) D.23449;
        __result = D.23447 - D.23450;
        D.23451 = __s1_len > 2;
        D.23431 = __result == 0;
        D.23452 = D.23451 & D.23431;
        if (D.23452 != 0) goto <D.23453>; else goto <D.23454>;
        <D.23453>:
        D.23455 = &MEM[(void *)"Ephemeron" + 3B];
        D.23456 = *D.23455;
        D.23457 = (int) D.23456;
        D.23458 = __s2 + 3;
        D.23459 = *D.23458;
        D.23460 = (int) D.23459;
        __result = D.23457 - D.23460;
        <D.23454>:
        <D.23444>:
        <D.23434>:
      }
      D.21331 = __result;
    }
    iftmp.26 = D.21331;
    goto <D.23461>;
    <D.23424>:
    D.23462 = class->name;
    iftmp.26 = __builtin_strcmp ("Ephemeron", D.23462);
    <D.23461>:
    D.21335 = iftmp.26;
  }
  if (D.21335 == 0) goto <D.23463>; else goto <D.23464>;
  <D.23463>:
  *max_set = 0;
  D.23465 = size / 8;
  D.23466 = (unsigned int) D.23465;
  memset (bitmap, 0, D.23466);
  D.23467 = bitmap;
  return D.23467;
  <D.23464>:
  <D.23421>:
  <D.23417>:
  p = class;
  goto <D.21370>;
  <D.21369>:
  {
    void * iter;

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

          if (static_fields != 0) goto <D.23468>; else goto <D.23469>;
          <D.23468>:
          D.23470 = field->type;
          D.23471 = D.23470->attrs;
          D.23472 = (int) D.23471;
          D.23473 = D.23472 & 272;
          if (D.23473 == 0) goto <D.23474>; else goto <D.23475>;
          <D.23474>:
          // predicted unlikely by continue predictor.
          goto <D.21338>;
          <D.23475>:
          D.23470 = field->type;
          D.23471 = D.23470->attrs;
          D.23472 = (int) D.23471;
          D.23476 = D.23472 & 64;
          if (D.23476 != 0) goto <D.23477>; else goto <D.23478>;
          <D.23477>:
          // predicted unlikely by continue predictor.
          goto <D.21338>;
          <D.23478>:
          goto <D.23479>;
          <D.23469>:
          D.23470 = field->type;
          D.23471 = D.23470->attrs;
          D.23472 = (int) D.23471;
          D.23473 = D.23472 & 272;
          if (D.23473 != 0) goto <D.23480>; else goto <D.23481>;
          <D.23480>:
          // predicted unlikely by continue predictor.
          goto <D.21338>;
          <D.23481>:
          <D.23479>:
          D.23470 = field->type;
          D.23482 = BIT_FIELD_REF <*D.23470, 8, 56>;
          D.23483 = D.23482 & 64;
          if (D.23483 != 0) goto <D.21339>; else goto <D.23484>;
          <D.23484>:
          if (static_fields != 0) goto <D.23485>; else goto <D.23486>;
          <D.23485>:
          D.23487 = field->offset;
          if (D.23487 == -1) goto <D.23488>; else goto <D.23489>;
          <D.23488>:
          // predicted unlikely by continue predictor.
          goto <D.21338>;
          <D.23489>:
          <D.23486>:
          D.23487 = field->offset;
          D.23490 = (unsigned int) D.23487;
          pos = D.23490 / 4;
          offset.27 = (unsigned int) offset;
          pos = pos + offset.27;
          D.23470 = field->type;
          type = mono_type_get_underlying_type (D.23470);
          D.23492 = type->type;
          D.23493 = (int) D.23492;
          switch (D.23493) <default: <D.21365>, case 2: <D.21363>, case 3: <D.21364>, case 4: <D.21353>, case 5: <D.21354>, case 6: <D.21355>, case 7: <D.21356>, case 8: <D.21357>, case 9: <D.21358>, case 10: <D.21359>, case 11: <D.21360>, case 12: <D.21361>, case 13: <D.21362>, case 14: <D.21345>, case 15: <D.21341>, case 17: <D.21351>, case 18: <D.21347>, case 20: <D.21349>, case 21: <D.21350>, case 24: <D.21340>, case 25: <D.21344>, case 27: <D.21342>, case 28: <D.21348>, case 29: <D.21346>>
          <D.21340>:
          <D.21341>:
          <D.21342>:
          goto <D.21343>;
          <D.21344>:
          goto <D.21343>;
          <D.21345>:
          <D.21346>:
          <D.21347>:
          <D.21348>:
          <D.21349>:
          D.23487 = field->offset;
          D.23490 = (unsigned int) D.23487;
          D.23494 = D.23490 & 3;
          D.23495 = D.23494 != 0;
          D.23496 = (long int) D.23495;
          D.23497 = __builtin_expect (D.23496, 0);
          if (D.23497 != 0) goto <D.23498>; else goto <D.23499>;
          <D.23498>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 722, "(field->offset % sizeof(gpointer)) == 0");
          <D.23499>:
          size.28 = (unsigned int) size;
          D.23501 = size.28 <= pos;
          max_size.29 = (unsigned int) max_size;
          D.23503 = max_size.29 < pos;
          D.23504 = D.23501 & D.23503;
          D.23505 = (int) D.23504;
          D.23506 = D.23505 != 0;
          D.23507 = (long int) D.23506;
          D.23508 = __builtin_expect (D.23507, 0);
          if (D.23508 != 0) goto <D.23509>; else goto <D.23510>;
          <D.23509>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 724, "pos < size || pos <= max_size");
          <D.23510>:
          D.23511 = pos / 32;
          D.23512 = D.23511 * 4;
          D.23513 = bitmap + D.23512;
          D.23512 = D.23511 * 4;
          D.23513 = bitmap + D.23512;
          D.23514 = *D.23513;
          pos.30 = (int) pos;
          D.23516 = pos.30 & 31;
          D.23517 = 1 << D.23516;
          D.23518 = D.23514 | D.23517;
          *D.23513 = D.23518;
          D.23519 = *max_set;
          D.23520 = (unsigned int) D.23519;
          D.23521 = MAX_EXPR <D.23520, pos>;
          D.23522 = (int) D.23521;
          *max_set = D.23522;
          goto <D.21343>;
          <D.21350>:
          D.23523 = mono_type_generic_inst_is_valuetype (type);
          if (D.23523 == 0) goto <D.23524>; else goto <D.23525>;
          <D.23524>:
          D.23487 = field->offset;
          D.23490 = (unsigned int) D.23487;
          D.23494 = D.23490 & 3;
          D.23495 = D.23494 != 0;
          D.23496 = (long int) D.23495;
          D.23497 = __builtin_expect (D.23496, 0);
          if (D.23497 != 0) goto <D.23526>; else goto <D.23527>;
          <D.23526>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 730, "(field->offset % sizeof(gpointer)) == 0");
          <D.23527>:
          D.23528 = pos / 32;
          D.23529 = D.23528 * 4;
          D.23530 = bitmap + D.23529;
          D.23529 = D.23528 * 4;
          D.23530 = bitmap + D.23529;
          D.23531 = *D.23530;
          pos.30 = (int) pos;
          D.23516 = pos.30 & 31;
          D.23517 = 1 << D.23516;
          D.23532 = D.23531 | D.23517;
          *D.23530 = D.23532;
          D.23519 = *max_set;
          D.23520 = (unsigned int) D.23519;
          D.23521 = MAX_EXPR <D.23520, pos>;
          D.23522 = (int) D.23521;
          *max_set = D.23522;
          goto <D.21343>;
          <D.23525>:
          <D.21351>:
          {
            struct MonoClass * fclass;

            D.23470 = field->type;
            fclass = mono_class_from_mono_type (D.23470);
            D.23533 = BIT_FIELD_REF <*fclass, 8, 184>;
            D.23534 = D.23533 & 8;
            if (D.23534 != 0) goto <D.23535>; else goto <D.23536>;
            <D.23535>:
            D.23537 = pos + 4294967294;
            D.23538 = (int) D.23537;
            compute_class_bitmap (fclass, bitmap, size, D.23538, max_set, 0);
            <D.23536>:
            goto <D.21343>;
          }
          <D.21353>:
          <D.21354>:
          <D.21355>:
          <D.21356>:
          <D.21357>:
          <D.21358>:
          <D.21359>:
          <D.21360>:
          <D.21361>:
          <D.21362>:
          <D.21363>:
          <D.21364>:
          goto <D.21343>;
          <D.21365>:
          D.23492 = type->type;
          D.23493 = (int) D.23492;
          D.23539 = field->parent;
          D.23540 = mono_type_get_full_name (D.23539);
          D.23541 = field->name;
          monoeg_g_log (0B, 4, "compute_class_bitmap: Invalid type %x for field %s:%s\n", D.23493, D.23540, D.23541);
          <D.21366>:
          goto <D.21366>;
          <D.21343>:
        }
        <D.21338>:
        field = mono_class_get_fields (p, &iter);
        if (field != 0B) goto <D.21367>; else goto <D.21339>;
        <D.21339>:
        if (static_fields != 0) goto <D.21368>; else goto <D.23542>;
        <D.23542>:
      }
    finally
      {
        iter = {CLOBBER};
      }
  }
  p = p->parent;
  <D.21370>:
  if (p != 0B) goto <D.21369>; else goto <D.21368>;
  <D.21368>:
  D.23467 = bitmap;
  return D.23467;
}


memset (void * __dest, int __ch, size_t __len)
{
  int D.23549;
  int D.23554;
  void * D.23556;
  unsigned int D.23557;

  D.23549 = __builtin_constant_p (__len);
  if (D.23549 != 0) goto <D.23550>; else goto <D.23551>;
  <D.23550>:
  if (__len == 0) goto <D.23552>; else goto <D.23553>;
  <D.23552>:
  D.23554 = __builtin_constant_p (__ch);
  if (D.23554 == 0) goto <D.23547>; else goto <D.23555>;
  <D.23555>:
  if (__ch != 0) goto <D.23547>; else goto <D.23548>;
  <D.23547>:
  __warn_memset_zero_len ();
  D.23556 = __dest;
  return D.23556;
  <D.23548>:
  <D.23553>:
  <D.23551>:
  D.23557 = __builtin_object_size (__dest, 0);
  D.23556 = __builtin___memset_chk (__dest, __ch, __len, D.23557);
  return D.23556;
}


mono_string_alloc (int length)
{
  struct MonoString * D.23559;
  struct MonoDomain * D.23560;

  D.23560 = mono_domain_get ();
  D.23559 = mono_string_new_size (D.23560, length);
  return D.23559;
}


mono_class_compute_gc_descriptor (struct MonoClass * class)
{
  int gcj_inited.31;
  struct MonoMethodSignature * D.23565;
  struct MonoMethodSignature * D.23566;
  struct MonoMethodSignature * D.23567;
  struct MonoMethodSignature * D.23568;
  unsigned char D.23569;
  unsigned char D.23570;
  unsigned char D.23573;
  unsigned char D.23574;
  struct MonoClass * D.23577;
  void * D.23580;
  unsigned char D.23582;
  struct MonoClass * D.23585;
  unsigned char D.23586;
  unsigned char D.23587;
  unsigned char D.23590;
  _Bool D.23591;
  int D.23592;
  void * D.23593;
  int D.23595;
  unsigned int D.23596;
  unsigned int D.23597;
  int D.23598;
  int D.23599;
  unsigned int D.23600;
  void * D.23601;
  int max_set.32;
  int D.23606;
  int D.23607;
  unsigned int D.23608;
  void * D.23609;
  int max_set;
  gsize * bitmap;
  gsize default_bitmap[4];
  static gboolean gcj_inited = 0;

  try
    {
      max_set = 0;
      default_bitmap = {};
      gcj_inited.31 = gcj_inited;
      if (gcj_inited.31 == 0) goto <D.23563>; else goto <D.23564>;
      <D.23563>:
      mono_loader_lock ();
      D.23565 = mono_create_icall_signature ("object ptr");
      mono_register_jit_icall (mono_object_new_ptrfree, "mono_object_new_ptrfree", D.23565, 0);
      D.23566 = mono_create_icall_signature ("object ptr");
      mono_register_jit_icall (mono_object_new_ptrfree_box, "mono_object_new_ptrfree_box", D.23566, 0);
      D.23567 = mono_create_icall_signature ("object ptr");
      mono_register_jit_icall (mono_object_new_fast, "mono_object_new_fast", D.23567, 0);
      D.23568 = mono_create_icall_signature ("object int");
      mono_register_jit_icall (mono_string_alloc, "mono_string_alloc", D.23568, 0);
      gcj_inited = 1;
      mono_loader_unlock ();
      <D.23564>:
      D.23569 = BIT_FIELD_REF <*class, 8, 160>;
      D.23570 = D.23569 & 1;
      if (D.23570 == 0) goto <D.23571>; else goto <D.23572>;
      <D.23571>:
      mono_class_init (class);
      <D.23572>:
      D.23573 = BIT_FIELD_REF <*class, 8, 184>;
      D.23574 = D.23573 & 2;
      if (D.23574 != 0) goto <D.23575>; else goto <D.23576>;
      <D.23575>:
      return;
      <D.23576>:
      class->gc_descr_inited = 1;
      class->gc_descr = 0B;
      bitmap = &default_bitmap;
      D.23577 = mono_defaults.string_class;
      if (D.23577 == class) goto <D.23578>; else goto <D.23579>;
      <D.23578>:
      D.23580 = mono_gc_make_descr_for_string (bitmap, 2);
      class->gc_descr = D.23580;
      goto <D.23581>;
      <D.23579>:
      D.23582 = class->rank;
      if (D.23582 != 0) goto <D.23583>; else goto <D.23584>;
      <D.23583>:
      D.23585 = class->element_class;
      mono_class_compute_gc_descriptor (D.23585);
      D.23585 = class->element_class;
      D.23586 = BIT_FIELD_REF <*D.23585, 8, 160>;
      D.23587 = D.23586 & 8;
      if (D.23587 == 0) goto <D.23588>; else goto <D.23589>;
      <D.23588>:
      {
        gsize abm;

        try
          {
            abm = 1;
            D.23590 = class->byval_arg.type;
            D.23591 = D.23590 == 29;
            D.23592 = (int) D.23591;
            D.23593 = mono_gc_make_descr_for_array (D.23592, &abm, 1, 4);
            class->gc_descr = D.23593;
          }
        finally
          {
            abm = {CLOBBER};
          }
      }
      goto <D.23594>;
      <D.23589>:
      D.23585 = class->element_class;
      bitmap = compute_class_bitmap (D.23585, &default_bitmap, 128, -2, &max_set, 0);
      D.23590 = class->byval_arg.type;
      D.23591 = D.23590 == 29;
      D.23592 = (int) D.23591;
      D.23595 = mono_array_element_size (class);
      D.23596 = (unsigned int) D.23595;
      D.23597 = D.23596 / 4;
      D.23598 = (int) D.23597;
      D.23599 = mono_array_element_size (class);
      D.23600 = (unsigned int) D.23599;
      D.23601 = mono_gc_make_descr_for_array (D.23592, bitmap, D.23598, D.23600);
      class->gc_descr = D.23601;
      if (&default_bitmap != bitmap) goto <D.23602>; else goto <D.23603>;
      <D.23602>:
      monoeg_g_free (bitmap);
      <D.23603>:
      <D.23594>:
      goto <D.23604>;
      <D.23584>:
      bitmap = compute_class_bitmap (class, &default_bitmap, 128, 0, &max_set, 0);
      max_set.32 = max_set;
      D.23606 = max_set.32 + 1;
      D.23607 = class->instance_size;
      D.23608 = (unsigned int) D.23607;
      D.23609 = mono_gc_make_descr_for_object (bitmap, D.23606, D.23608);
      class->gc_descr = D.23609;
      if (&default_bitmap != bitmap) goto <D.23610>; else goto <D.23611>;
      <D.23610>:
      monoeg_g_free (bitmap);
      <D.23611>:
      <D.23604>:
      <D.23581>:
    }
  finally
    {
      max_set = {CLOBBER};
      default_bitmap = {CLOBBER};
    }
}


mono_object_new_ptrfree_box (struct MonoVTable * vtable)
{
  struct MonoClass * D.23615;
  int D.23616;
  unsigned int D.23617;
  struct MonoObject * D.23618;
  struct MonoObject * obj;

  D.23615 = vtable->klass;
  D.23616 = D.23615->instance_size;
  D.23617 = (unsigned int) D.23616;
  obj = mono_gc_alloc_obj (vtable, D.23617);
  D.23618 = obj;
  return D.23618;
}


mono_object_new_ptrfree (struct MonoVTable * vtable)
{
  struct MonoClass * D.23620;
  int D.23621;
  unsigned int D.23622;
  struct MonoObject * D.23623;
  struct MonoObject * obj;

  D.23620 = vtable->klass;
  D.23621 = D.23620->instance_size;
  D.23622 = (unsigned int) D.23621;
  obj = mono_gc_alloc_obj (vtable, D.23622);
  D.23623 = obj;
  return D.23623;
}


mono_method_get_imt_slot (struct MonoMethod * method)
{
  unsigned char D.23625;
  unsigned char D.23626;
  short unsigned int D.23629;
  int D.23630;
  unsigned int hashes_count.33;
  unsigned int D.23632;
  struct MonoClass * D.23633;
  unsigned int D.23634;
  unsigned int D.23635;
  unsigned char D.23638;
  const char * D.23643;
  const char * D.23644;
  const char * D.23645;
  unsigned int D.23646;
  guint32 * D.23647;
  unsigned int D.23648;
  guint32 * D.23649;
  unsigned int D.23650;
  guint32 * D.23651;
  struct MonoType * D.23652;
  unsigned int D.23653;
  int D.23654;
  unsigned int D.23655;
  unsigned int D.23656;
  guint32 * D.23657;
  struct MonoType * D.23658;
  unsigned int D.23659;
  unsigned int D.23660;
  unsigned int D.23661;
  unsigned int D.23662;
  unsigned int D.23663;
  unsigned int D.23664;
  unsigned int D.23665;
  unsigned int D.23666;
  unsigned int D.23667;
  unsigned int D.23668;
  unsigned int D.23669;
  unsigned int D.23670;
  unsigned int D.23671;
  unsigned int D.23672;
  unsigned int D.23673;
  unsigned int D.23674;
  unsigned int D.23675;
  guint32 D.23677;
  struct MonoMethodSignature * sig;
  int hashes_count;
  guint32 * hashes_start;
  guint32 * hashes;
  guint32 a;
  guint32 b;
  guint32 c;
  int i;

  D.23625 = BIT_FIELD_REF <*method, 8, 168>;
  D.23626 = D.23625 & 16;
  if (D.23626 != 0) goto <D.23627>; else goto <D.23628>;
  <D.23627>:
  method = MEM[(struct MonoMethodInflated *)method].declaring;
  <D.23628>:
  sig = mono_method_signature (method);
  D.23629 = sig->param_count;
  D.23630 = (int) D.23629;
  hashes_count = D.23630 + 4;
  hashes_count.33 = (unsigned int) hashes_count;
  D.23632 = hashes_count.33 * 4;
  hashes_start = malloc (D.23632);
  hashes = hashes_start;
  D.23633 = method->klass;
  D.23634 = D.23633->flags;
  D.23635 = D.23634 & 32;
  if (D.23635 == 0) goto <D.23636>; else goto <D.23637>;
  <D.23636>:
  D.23633 = method->klass;
  D.23638 = D.23633->byval_arg.type;
  if (D.23638 != 19) goto <D.23639>; else goto <D.23640>;
  <D.23639>:
  D.23633 = method->klass;
  D.23638 = D.23633->byval_arg.type;
  if (D.23638 != 30) goto <D.23641>; else goto <D.23642>;
  <D.23641>:
  D.23633 = method->klass;
  D.23643 = D.23633->name_space;
  D.23633 = method->klass;
  D.23644 = D.23633->name;
  D.23645 = method->name;
  monoeg_g_log (0B, 4, "mono_method_get_imt_slot: %s.%s.%s is not an interface MonoMethod", D.23643, D.23644, D.23645);
  <D.21429>:
  goto <D.21429>;
  <D.23642>:
  <D.23640>:
  <D.23637>:
  D.23633 = method->klass;
  D.23644 = D.23633->name;
  D.23646 = mono_metadata_str_hash (D.23644);
  *hashes = D.23646;
  D.23647 = hashes + 4;
  D.23633 = method->klass;
  D.23643 = D.23633->name_space;
  D.23648 = mono_metadata_str_hash (D.23643);
  *D.23647 = D.23648;
  D.23649 = hashes + 8;
  D.23645 = method->name;
  D.23650 = mono_metadata_str_hash (D.23645);
  *D.23649 = D.23650;
  D.23651 = hashes + 12;
  D.23652 = sig->ret;
  D.23653 = mono_metadata_type_hash (D.23652);
  *D.23651 = D.23653;
  i = 0;
  goto <D.21431>;
  <D.21430>:
  D.23654 = i + 4;
  D.23655 = (unsigned int) D.23654;
  D.23656 = D.23655 * 4;
  D.23657 = hashes + D.23656;
  D.23658 = sig->params[i];
  D.23659 = mono_metadata_type_hash (D.23658);
  *D.23657 = D.23659;
  i = i + 1;
  <D.21431>:
  D.23629 = sig->param_count;
  D.23630 = (int) D.23629;
  if (D.23630 > i) goto <D.21430>; else goto <D.21432>;
  <D.21432>:
  hashes_count.33 = (unsigned int) hashes_count;
  D.23660 = hashes_count.33 << 2;
  c = D.23660 + 3735928559;
  b = c;
  a = b;
  goto <D.21434>;
  <D.21433>:
  D.23661 = *hashes;
  a = D.23661 + a;
  D.23647 = hashes + 4;
  D.23662 = *D.23647;
  b = D.23662 + b;
  D.23649 = hashes + 8;
  D.23663 = *D.23649;
  c = D.23663 + c;
  a = a - c;
  D.23664 = c r>> 28;
  a = D.23664 ^ a;
  c = c + b;
  b = b - a;
  D.23665 = a r>> 26;
  b = D.23665 ^ b;
  a = a + c;
  c = c - b;
  D.23666 = b r>> 24;
  c = D.23666 ^ c;
  b = b + a;
  a = a - c;
  D.23667 = c r>> 16;
  a = D.23667 ^ a;
  c = c + b;
  b = b - a;
  D.23668 = a r>> 13;
  b = D.23668 ^ b;
  a = a + c;
  c = c - b;
  D.23669 = b r>> 28;
  c = D.23669 ^ c;
  b = b + a;
  hashes_count = hashes_count + -3;
  hashes = hashes + 12;
  <D.21434>:
  if (hashes_count > 3) goto <D.21433>; else goto <D.21435>;
  <D.21435>:
  switch (hashes_count) <default: <D.23676>, case 0: <D.21439>, case 1: <D.21438>, case 2: <D.21437>, case 3: <D.21436>>
  <D.21436>:
  D.23649 = hashes + 8;
  D.23663 = *D.23649;
  c = D.23663 + c;
  <D.21437>:
  D.23647 = hashes + 4;
  D.23662 = *D.23647;
  b = D.23662 + b;
  <D.21438>:
  D.23661 = *hashes;
  a = D.23661 + a;
  c = c ^ b;
  D.23670 = b r>> 18;
  c = c - D.23670;
  a = a ^ c;
  D.23671 = c r>> 21;
  a = a - D.23671;
  b = b ^ a;
  D.23672 = a r>> 7;
  b = b - D.23672;
  c = c ^ b;
  D.23673 = b r>> 16;
  c = c - D.23673;
  a = a ^ c;
  D.23664 = c r>> 28;
  a = a - D.23664;
  b = b ^ a;
  D.23674 = a r>> 18;
  b = b - D.23674;
  c = c ^ b;
  D.23675 = b r>> 8;
  c = c - D.23675;
  <D.21439>:
  goto <D.21440>;
  <D.23676>:
  <D.21440>:
  free (hashes_start);
  D.23677 = c % 19;
  return D.23677;
}


mono_vtable_build_imt_slot (struct MonoVTable * vtable, int imt_slot)
{
  unsigned int imt_slot.34;
  _Bool D.23680;
  long int D.23681;
  long int D.23682;
  struct MonoDomain * D.23685;
  union mono_mutex_t * D.23686;
  _Bool D.23689;
  long int D.23690;
  long int D.23691;
  unsigned int imt_slot.35;
  unsigned int D.23695;
  void * * D.23696;
  void * D.23697;
  void * (*<T2f17>) (int) D.23698;
  void * D.23699;
  struct MonoClass * D.23702;
  _Bool D.23705;
  long int D.23706;
  long int D.23707;
  void * * imt;

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

    D.23685 = vtable->domain;
    D.23686 = &D.23685->lock.mutex;
    ret = pthread_mutex_lock (D.23686);
    if (ret != 0) goto <D.23687>; else goto <D.23688>;
    <D.23687>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
    <D.23688>:
    D.23689 = ret != 0;
    D.23690 = (long int) D.23689;
    D.23691 = __builtin_expect (D.23690, 0);
    if (D.23691 != 0) goto <D.23692>; else goto <D.23693>;
    <D.23692>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 1460, "ret == 0");
    <D.23693>:
  }
  imt_slot.35 = (unsigned int) imt_slot;
  D.23695 = imt_slot.35 * 4;
  D.23696 = imt + D.23695;
  D.23697 = *D.23696;
  D.23698 = callbacks.get_imt_trampoline;
  D.23699 = D.23698 (imt_slot);
  if (D.23697 == D.23699) goto <D.23700>; else goto <D.23701>;
  <D.23700>:
  D.23702 = vtable->klass;
  D.23685 = vtable->domain;
  build_imt_slots (D.23702, vtable, D.23685, imt, 0B, imt_slot);
  <D.23701>:
  {
    int ret;

    D.23685 = vtable->domain;
    D.23686 = &D.23685->lock.mutex;
    ret = pthread_mutex_unlock (D.23686);
    if (ret != 0) goto <D.23703>; else goto <D.23704>;
    <D.23703>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.23704>:
    D.23705 = ret != 0;
    D.23706 = (long int) D.23705;
    D.23707 = __builtin_expect (D.23706, 0);
    if (D.23707 != 0) goto <D.23708>; else goto <D.23709>;
    <D.23708>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 1464, "ret == 0");
    <D.23709>:
  }
  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.23710;
  unsigned int i.36;
  unsigned int D.23712;
  struct MonoClass * * D.23713;
  guint16 * D.23714;
  unsigned int D.23715;
  guint16 * D.23716;
  short unsigned int D.23717;
  int D.23718;
  unsigned char D.23723;
  unsigned char D.23724;
  struct MonoGenericClass * D.23727;
  struct MonoClass * D.23728;
  unsigned int D.23729;
  unsigned int slot_num.37;
  unsigned char D.23733;
  unsigned char D.23734;
  short unsigned int D.23737;
  int D.23738;
  int D.23739;
  unsigned int method_slot_in_interface.38;
  unsigned int D.23743;
  short unsigned int D.23744;
  int D.23745;
  int D.23748;
  unsigned int method_slot_in_interface.39;
  unsigned int D.23750;
  unsigned int interface_offset.40;
  unsigned int D.23752;
  _Bool D.23753;
  _Bool D.23754;
  _Bool D.23755;
  void * * D.23758;
  struct MonoImtBuilderEntry * * D.23761;
  struct MonoImtBuilderEntry * D.23762;
  struct _MonoImtBuilderEntry * D.23765;
  int D.23766;
  int D.23767;
  int D.23768;
  int D.23769;
  int D.23770;
  int D.23773;
  unsigned int D.23774;
  unsigned int imt_collisions_bitmap.41;
  unsigned int imt_collisions_bitmap.42;
  void * iftmp.43;
  void * (*<T2f17>) (int) D.23778;
  void * D.23782;
  void * D.23784;
  long unsigned int methods_in_slot.44;
  long unsigned int D.23788;
  long unsigned int methods_in_slot.45;
  long unsigned int D.23792;
  long unsigned int method_count.46;
  long unsigned int D.23794;
  long unsigned int method_count.47;
  unsigned int D.23798;
  unsigned int D.23799;
  int i;
  struct GSList * list_item;
  guint32 imt_collisions_bitmap;
  struct MonoImtBuilderEntry * * imt_builder;
  int method_count;
  gboolean record_method_count_for_max_collisions;
  gboolean has_generic_virtual;
  gboolean has_variant_iface;

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

        D.23710 = klass->interfaces_packed;
        i.36 = (unsigned int) i;
        D.23712 = i.36 * 4;
        D.23713 = D.23710 + D.23712;
        iface = *D.23713;
        D.23714 = klass->interface_offsets_packed;
        i.36 = (unsigned int) i;
        D.23715 = i.36 * 2;
        D.23716 = D.23714 + D.23715;
        D.23717 = *D.23716;
        interface_offset = (int) D.23717;
        D.23718 = mono_class_has_variant_generic_params (iface);
        if (D.23718 != 0) goto <D.23719>; else goto <D.23720>;
        <D.23719>:
        has_variant_iface = 1;
        <D.23720>:
        mono_class_setup_methods (iface);
        vt_slot = interface_offset;
        method_slot_in_interface = 0;
        goto <D.21520>;
        <D.21519>:
        {
          struct MonoMethod * method;

          if (slot_num >= 0) goto <D.23721>; else goto <D.23722>;
          <D.23721>:
          D.23723 = BIT_FIELD_REF <*iface, 8, 192>;
          D.23724 = D.23723 & 8;
          if (D.23724 != 0) goto <D.23725>; else goto <D.23726>;
          <D.23725>:
          D.23727 = iface->generic_class;
          D.23728 = D.23727->container_class;
          method = mono_class_get_method_by_index (D.23728, method_slot_in_interface);
          D.23729 = mono_method_get_imt_slot (method);
          slot_num.37 = (unsigned int) slot_num;
          if (D.23729 != slot_num.37) goto <D.23731>; else goto <D.23732>;
          <D.23731>:
          vt_slot = vt_slot + 1;
          // predicted unlikely by continue predictor.
          goto <D.21518>;
          <D.23732>:
          <D.23726>:
          <D.23722>:
          method = mono_class_get_method_by_index (iface, method_slot_in_interface);
          D.23733 = BIT_FIELD_REF <*method, 8, 168>;
          D.23734 = D.23733 & 8;
          if (D.23734 != 0) goto <D.23735>; else goto <D.23736>;
          <D.23735>:
          has_generic_virtual = 1;
          vt_slot = vt_slot + 1;
          // predicted unlikely by continue predictor.
          goto <D.21518>;
          <D.23736>:
          D.23737 = method->flags;
          D.23738 = (int) D.23737;
          D.23739 = D.23738 & 16;
          if (D.23739 == 0) goto <D.23740>; else goto <D.23741>;
          <D.23740>:
          add_imt_builder_entry (imt_builder, method, &imt_collisions_bitmap, vt_slot, slot_num);
          vt_slot = vt_slot + 1;
          <D.23741>:
        }
        <D.21518>:
        method_slot_in_interface = method_slot_in_interface + 1;
        <D.21520>:
        method_slot_in_interface.38 = (unsigned int) method_slot_in_interface;
        D.23743 = iface->method.count;
        if (method_slot_in_interface.38 < D.23743) goto <D.21519>; else goto <D.21521>;
        <D.21521>:
      }
      i = i + 1;
      <D.21523>:
      D.23744 = klass->interface_offsets_count;
      D.23745 = (int) D.23744;
      if (D.23745 > i) goto <D.21522>; else goto <D.21524>;
      <D.21524>:
      if (extra_interfaces != 0B) goto <D.23746>; else goto <D.23747>;
      <D.23746>:
      {
        int interface_offset;

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

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

            method = mono_class_get_method_by_index (iface, method_slot_in_interface);
            D.23748 = interface_offset + method_slot_in_interface;
            add_imt_builder_entry (imt_builder, method, &imt_collisions_bitmap, D.23748, slot_num);
          }
          method_slot_in_interface = method_slot_in_interface + 1;
          <D.21530>:
          method_slot_in_interface.39 = (unsigned int) method_slot_in_interface;
          D.23750 = iface->method.count;
          if (method_slot_in_interface.39 < D.23750) goto <D.21529>; else goto <D.21531>;
          <D.21531>:
          D.23750 = iface->method.count;
          interface_offset.40 = (unsigned int) interface_offset;
          D.23752 = D.23750 + interface_offset.40;
          interface_offset = (int) D.23752;
        }
        list_item = list_item->next;
        <D.21533>:
        if (list_item != 0B) goto <D.21532>; else goto <D.21534>;
        <D.21534>:
      }
      <D.23747>:
      i = 0;
      goto <D.21542>;
      <D.21541>:
      D.23753 = slot_num < 0;
      D.23754 = i == slot_num;
      D.23755 = D.23753 | D.23754;
      if (D.23755 != 0) goto <D.23756>; else goto <D.23757>;
      <D.23756>:
      {
        struct MonoImtBuilderEntry * entries;

        i.36 = (unsigned int) i;
        D.23712 = i.36 * 4;
        D.23758 = imt + D.23712;
        entries = get_generic_virtual_entries (domain, D.23758);
        if (entries != 0B) goto <D.23759>; else goto <D.23760>;
        <D.23759>:
        i.36 = (unsigned int) i;
        D.23712 = i.36 * 4;
        D.23761 = imt_builder + D.23712;
        D.23762 = *D.23761;
        if (D.23762 != 0B) goto <D.23763>; else goto <D.23764>;
        <D.23763>:
        {
          struct MonoImtBuilderEntry * entry;

          entry = entries;
          goto <D.21538>;
          <D.21537>:
          entry = entry->next;
          <D.21538>:
          D.23765 = entry->next;
          if (D.23765 != 0B) goto <D.21537>; else goto <D.21539>;
          <D.21539>:
          i.36 = (unsigned int) i;
          D.23712 = i.36 * 4;
          D.23761 = imt_builder + D.23712;
          D.23762 = *D.23761;
          entry->next = D.23762;
          D.23766 = entries->children;
          i.36 = (unsigned int) i;
          D.23712 = i.36 * 4;
          D.23761 = imt_builder + D.23712;
          D.23762 = *D.23761;
          D.23767 = D.23762->children;
          D.23768 = D.23767 + 1;
          D.23769 = D.23766 + D.23768;
          entries->children = D.23769;
        }
        <D.23764>:
        i.36 = (unsigned int) i;
        D.23712 = i.36 * 4;
        D.23761 = imt_builder + D.23712;
        *D.23761 = entries;
        <D.23760>:
        D.23770 = has_generic_virtual | has_variant_iface;
        if (D.23770 != 0) goto <D.23771>; else goto <D.23772>;
        <D.23771>:
        D.23773 = 1 << i;
        D.23774 = (unsigned int) D.23773;
        imt_collisions_bitmap.41 = imt_collisions_bitmap;
        imt_collisions_bitmap.42 = D.23774 | imt_collisions_bitmap.41;
        imt_collisions_bitmap = imt_collisions_bitmap.42;
        i.36 = (unsigned int) i;
        D.23712 = i.36 * 4;
        D.23758 = imt + D.23712;
        i.36 = (unsigned int) i;
        D.23712 = i.36 * 4;
        D.23761 = imt_builder + D.23712;
        D.23762 = *D.23761;
        D.23778 = callbacks.get_imt_trampoline;
        if (D.23778 != 0B) goto <D.23779>; else goto <D.23780>;
        <D.23779>:
        D.23778 = callbacks.get_imt_trampoline;
        iftmp.43 = D.23778 (i);
        goto <D.23781>;
        <D.23780>:
        iftmp.43 = 0B;
        <D.23781>:
        D.23782 = initialize_imt_slot (vt, domain, D.23762, iftmp.43);
        *D.23758 = D.23782;
        goto <D.23783>;
        <D.23772>:
        i.36 = (unsigned int) i;
        D.23712 = i.36 * 4;
        D.23758 = imt + D.23712;
        i.36 = (unsigned int) i;
        D.23712 = i.36 * 4;
        D.23761 = imt_builder + D.23712;
        D.23762 = *D.23761;
        D.23784 = initialize_imt_slot (vt, domain, D.23762, 0B);
        *D.23758 = D.23784;
        <D.23783>:
      }
      <D.23757>:
      i.36 = (unsigned int) i;
      D.23712 = i.36 * 4;
      D.23761 = imt_builder + D.23712;
      D.23762 = *D.23761;
      if (D.23762 != 0B) goto <D.23785>; else goto <D.23786>;
      <D.23785>:
      {
        int methods_in_slot;

        i.36 = (unsigned int) i;
        D.23712 = i.36 * 4;
        D.23761 = imt_builder + D.23712;
        D.23762 = *D.23761;
        D.23767 = D.23762->children;
        methods_in_slot = D.23767 + 1;
        methods_in_slot.44 = (long unsigned int) methods_in_slot;
        D.23788 = mono_stats.imt_max_collisions_in_slot;
        if (methods_in_slot.44 > D.23788) goto <D.23789>; else goto <D.23790>;
        <D.23789>:
        methods_in_slot.45 = (long unsigned int) methods_in_slot;
        mono_stats.imt_max_collisions_in_slot = methods_in_slot.45;
        record_method_count_for_max_collisions = 1;
        <D.23790>:
        method_count = method_count + methods_in_slot;
      }
      <D.23786>:
      i = i + 1;
      <D.21542>:
      if (i <= 18) goto <D.21541>; else goto <D.21543>;
      <D.21543>:
      D.23792 = mono_stats.imt_number_of_methods;
      method_count.46 = (long unsigned int) method_count;
      D.23794 = D.23792 + method_count.46;
      mono_stats.imt_number_of_methods = D.23794;
      if (record_method_count_for_max_collisions != 0) goto <D.23795>; else goto <D.23796>;
      <D.23795>:
      method_count.47 = (long unsigned int) method_count;
      mono_stats.imt_method_count_when_max_collisions = method_count.47;
      <D.23796>:
      i = 0;
      goto <D.21550>;
      <D.21549>:
      {
        struct MonoImtBuilderEntry * entry;

        i.36 = (unsigned int) i;
        D.23712 = i.36 * 4;
        D.23761 = imt_builder + D.23712;
        entry = *D.23761;
        goto <D.21547>;
        <D.21546>:
        {
          struct MonoImtBuilderEntry * next;

          next = entry->next;
          monoeg_g_free (entry);
          entry = next;
        }
        <D.21547>:
        if (entry != 0B) goto <D.21546>; else goto <D.21548>;
        <D.21548>:
      }
      i = i + 1;
      <D.21550>:
      if (i <= 18) goto <D.21549>; else goto <D.21551>;
      <D.21551>:
      free (imt_builder);
      D.23798 = vt->imt_collisions_bitmap;
      imt_collisions_bitmap.41 = imt_collisions_bitmap;
      D.23799 = D.23798 | imt_collisions_bitmap.41;
      vt->imt_collisions_bitmap = D.23799;
    }
  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.23800;
  unsigned int slot_num.48;
  _Bool D.23802;
  _Bool D.23803;
  unsigned int D.23806;
  struct MonoImtBuilderEntry * * D.23807;
  struct MonoImtBuilderEntry * D.23808;
  int D.23811;
  int D.23812;
  int D.23813;
  long unsigned int D.23816;
  long unsigned int D.23817;
  unsigned int D.23818;
  int imt_slot.49;
  int D.23820;
  unsigned int D.23821;
  unsigned int D.23822;
  long unsigned int D.23824;
  long unsigned int D.23825;
  guint32 imt_slot;
  struct MonoImtBuilderEntry * entry;

  imt_slot = mono_method_get_imt_slot (method);
  D.23800 = slot_num >= 0;
  slot_num.48 = (unsigned int) slot_num;
  D.23802 = slot_num.48 != imt_slot;
  D.23803 = D.23800 & D.23802;
  if (D.23803 != 0) goto <D.23804>; else goto <D.23805>;
  <D.23804>:
  return;
  <D.23805>:
  entry = monoeg_malloc0 (20);
  entry->key = method;
  entry->value.vtable_slot = vtable_slot;
  D.23806 = imt_slot * 4;
  D.23807 = imt_builder + D.23806;
  D.23808 = *D.23807;
  entry->next = D.23808;
  D.23806 = imt_slot * 4;
  D.23807 = imt_builder + D.23806;
  D.23808 = *D.23807;
  if (D.23808 != 0B) goto <D.23809>; else goto <D.23810>;
  <D.23809>:
  D.23806 = imt_slot * 4;
  D.23807 = imt_builder + D.23806;
  D.23808 = *D.23807;
  D.23811 = D.23808->children;
  D.23812 = D.23811 + 1;
  entry->children = D.23812;
  D.23813 = entry->children;
  if (D.23813 == 1) goto <D.23814>; else goto <D.23815>;
  <D.23814>:
  D.23816 = mono_stats.imt_slots_with_collisions;
  D.23817 = D.23816 + 1;
  mono_stats.imt_slots_with_collisions = D.23817;
  D.23818 = *imt_collisions_bitmap;
  imt_slot.49 = (int) imt_slot;
  D.23820 = 1 << imt_slot.49;
  D.23821 = (unsigned int) D.23820;
  D.23822 = D.23818 | D.23821;
  *imt_collisions_bitmap = D.23822;
  <D.23815>:
  goto <D.23823>;
  <D.23810>:
  entry->children = 0;
  D.23824 = mono_stats.imt_used_slots;
  D.23825 = D.23824 + 1;
  mono_stats.imt_used_slots = D.23825;
  <D.23823>:
  D.23806 = imt_slot * 4;
  D.23807 = imt_builder + D.23806;
  *D.23807 = entry;
}


get_generic_virtual_entries (struct MonoDomain * domain, void * * vtable_slot)
{
  union mono_mutex_t * D.23827;
  _Bool D.23830;
  long int D.23831;
  long int D.23832;
  struct GHashTable * D.23835;
  struct GHashTable * D.23838;
  int D.23839;
  struct MonoMethod * D.23842;
  void * D.23843;
  void * D.23844;
  int D.23847;
  int D.23848;
  _Bool D.23851;
  long int D.23852;
  long int D.23853;
  struct MonoImtBuilderEntry * D.23856;
  struct GenericVirtualCase * list;
  struct MonoImtBuilderEntry * entries;

  {
    int ret;

    D.23827 = &domain->lock.mutex;
    ret = pthread_mutex_lock (D.23827);
    if (ret != 0) goto <D.23828>; else goto <D.23829>;
    <D.23828>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
    <D.23829>:
    D.23830 = ret != 0;
    D.23831 = (long int) D.23830;
    D.23832 = __builtin_expect (D.23831, 0);
    if (D.23832 != 0) goto <D.23833>; else goto <D.23834>;
    <D.23833>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 1645, "ret == 0");
    <D.23834>:
  }
  D.23835 = domain->generic_virtual_cases;
  if (D.23835 == 0B) goto <D.23836>; else goto <D.23837>;
  <D.23836>:
  D.23838 = monoeg_g_hash_table_new (mono_aligned_addr_hash, 0B);
  domain->generic_virtual_cases = D.23838;
  <D.23837>:
  D.23835 = domain->generic_virtual_cases;
  list = monoeg_g_hash_table_lookup (D.23835, vtable_slot);
  entries = 0B;
  goto <D.21627>;
  <D.21626>:
  {
    struct MonoImtBuilderEntry * entry;

    D.23839 = list->count;
    if (D.23839 <= 9) goto <D.23840>; else goto <D.23841>;
    <D.23840>:
    // predicted unlikely by continue predictor.
    goto <D.21625>;
    <D.23841>:
    entry = monoeg_malloc0 (20);
    D.23842 = list->method;
    entry->key = D.23842;
    D.23843 = list->code;
    D.23844 = mono_get_addr_from_ftnptr (D.23843);
    entry->value.target_code = D.23844;
    entry->has_target_code = 1;
    if (entries != 0B) goto <D.23845>; else goto <D.23846>;
    <D.23845>:
    D.23847 = entries->children;
    D.23848 = D.23847 + 1;
    entry->children = D.23848;
    <D.23846>:
    entry->next = entries;
    entries = entry;
  }
  <D.21625>:
  list = list->next;
  <D.21627>:
  if (list != 0B) goto <D.21626>; else goto <D.21628>;
  <D.21628>:
  {
    int ret;

    D.23827 = &domain->lock.mutex;
    ret = pthread_mutex_unlock (D.23827);
    if (ret != 0) goto <D.23849>; else goto <D.23850>;
    <D.23849>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.23850>:
    D.23851 = ret != 0;
    D.23852 = (long int) D.23851;
    D.23853 = __builtin_expect (D.23852, 0);
    if (D.23853 != 0) goto <D.23854>; else goto <D.23855>;
    <D.23854>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 1668, "ret == 0");
    <D.23855>:
  }
  D.23856 = entries;
  return D.23856;
}


initialize_imt_slot (struct MonoVTable * vtable, struct MonoDomain * domain, struct MonoImtBuilderEntry * imt_builder_entry, void * fail_tramp)
{
  int D.23861;
  void * D.23864;
  int D.23865;
  void * (*<T314f>) (struct MonoVTable *, struct MonoDomain *, struct MonoIMTCheckItem * *, int, void *) imt_thunk_builder.50;
  void * * D.23867;
  unsigned int D.23868;
  int D.23869;
  unsigned int i.51;
  unsigned int D.23871;
  void * * D.23872;
  void * D.23873;
  unsigned int i.52;

  if (imt_builder_entry != 0B) goto <D.23858>; else goto <D.23859>;
  <D.23858>:
  D.23861 = imt_builder_entry->children;
  if (D.23861 == 0) goto <D.23862>; else goto <D.23860>;
  <D.23862>:
  if (fail_tramp == 0B) goto <D.23863>; else goto <D.23860>;
  <D.23863>:
  D.23865 = imt_builder_entry->value.vtable_slot;
  D.23864 = vtable->vtable[D.23865];
  return D.23864;
  <D.23860>:
  {
    struct GPtrArray * imt_ir;
    void * result;
    int i;

    imt_ir = imt_sort_slot_entries (imt_builder_entry);
    imt_thunk_builder.50 = imt_thunk_builder;
    D.23867 = imt_ir->pdata;
    D.23868 = imt_ir->len;
    D.23869 = (int) D.23868;
    result = imt_thunk_builder.50 (vtable, domain, D.23867, D.23869, fail_tramp);
    i = 0;
    goto <D.21492>;
    <D.21491>:
    D.23867 = imt_ir->pdata;
    i.51 = (unsigned int) i;
    D.23871 = i.51 * 4;
    D.23872 = D.23867 + D.23871;
    D.23873 = *D.23872;
    monoeg_g_free (D.23873);
    i = i + 1;
    <D.21492>:
    i.52 = (unsigned int) i;
    D.23868 = imt_ir->len;
    if (i.52 < D.23868) goto <D.21491>; else goto <D.21493>;
    <D.21493>:
    monoeg_g_ptr_array_free (imt_ir, 1);
    D.23864 = result;
    return D.23864;
  }
  <D.23859>:
  if (fail_tramp != 0B) goto <D.23875>; else goto <D.23876>;
  <D.23875>:
  D.23864 = fail_tramp;
  return D.23864;
  <D.23876>:
  D.23864 = 0B;
  return D.23864;
}


imt_sort_slot_entries (struct MonoImtBuilderEntry * entries)
{
  int D.23878;
  unsigned int number_of_entries.53;
  unsigned int D.23880;
  unsigned int i.54;
  unsigned int D.23882;
  struct MonoImtBuilderEntry * * D.23883;
  unsigned int number_of_entries.55;
  struct GPtrArray * D.23885;
  int number_of_entries;
  struct MonoImtBuilderEntry * * sorted_array;
  struct GPtrArray * result;
  struct MonoImtBuilderEntry * current_entry;
  int i;

  D.23878 = entries->children;
  number_of_entries = D.23878 + 1;
  number_of_entries.53 = (unsigned int) number_of_entries;
  D.23880 = number_of_entries.53 * 4;
  sorted_array = malloc (D.23880);
  result = monoeg_g_ptr_array_new ();
  current_entry = entries;
  i = 0;
  goto <D.21480>;
  <D.21479>:
  i.54 = (unsigned int) i;
  D.23882 = i.54 * 4;
  D.23883 = sorted_array + D.23882;
  *D.23883 = current_entry;
  current_entry = current_entry->next;
  i = i + 1;
  <D.21480>:
  if (current_entry != 0B) goto <D.21479>; else goto <D.21481>;
  <D.21481>:
  number_of_entries.55 = (unsigned int) number_of_entries;
  qsort (sorted_array, number_of_entries.55, 4, compare_imt_builder_entries);
  imt_emit_ir (sorted_array, 0, number_of_entries, result);
  free (sorted_array);
  D.23885 = result;
  return D.23885;
}


compare_imt_builder_entries (const void * p1, const void * p2)
{
  int D.23887;
  int iftmp.56;
  void * D.23889;
  void * D.23890;
  _Bool D.23893;
  struct MonoImtBuilderEntry * e1;
  struct MonoImtBuilderEntry * e2;

  e1 = MEM[(struct MonoImtBuilderEntry * *)p1];
  e2 = MEM[(struct MonoImtBuilderEntry * *)p2];
  D.23889 = e1->key;
  D.23890 = e2->key;
  if (D.23889 >= D.23890) goto <D.23891>; else goto <D.23892>;
  <D.23891>:
  D.23889 = e1->key;
  D.23890 = e2->key;
  D.23893 = D.23889 > D.23890;
  iftmp.56 = (int) D.23893;
  goto <D.23894>;
  <D.23892>:
  iftmp.56 = -1;
  <D.23894>:
  D.23887 = iftmp.56;
  return D.23887;
}


imt_emit_ir (struct MonoImtBuilderEntry * * sorted_array, int start, int end, struct GPtrArray * out_array)
{
  unsigned int D.23896;
  unsigned int i.57;
  unsigned int D.23900;
  struct MonoImtBuilderEntry * * D.23901;
  struct MonoImtBuilderEntry * D.23902;
  void * D.23903;
  <unnamed-unsigned:1> D.23904;
  unsigned char D.23905;
  int D.23906;
  unsigned int D.23909;
  int D.23910;
  int D.23913;
  unsigned int middle.58;
  unsigned int D.23915;
  struct MonoImtBuilderEntry * * D.23916;
  struct MonoImtBuilderEntry * D.23917;
  void * D.23918;
  int D.23919;
  int D.23920;
  int count;
  int chunk_start;

  count = end - start;
  D.23896 = out_array->len;
  chunk_start = (int) D.23896;
  if (count <= 3) goto <D.23897>; else goto <D.23898>;
  <D.23897>:
  {
    int i;

    i = start;
    goto <D.21467>;
    <D.21466>:
    {
      struct MonoIMTCheckItem * item;

      item = monoeg_malloc0 (28);
      i.57 = (unsigned int) i;
      D.23900 = i.57 * 4;
      D.23901 = sorted_array + D.23900;
      D.23902 = *D.23901;
      D.23903 = D.23902->key;
      item->key = D.23903;
      i.57 = (unsigned int) i;
      D.23900 = i.57 * 4;
      D.23901 = sorted_array + D.23900;
      D.23902 = *D.23901;
      item->value = D.23902->value;
      i.57 = (unsigned int) i;
      D.23900 = i.57 * 4;
      D.23901 = sorted_array + D.23900;
      D.23902 = *D.23901;
      D.23904 = D.23902->has_target_code;
      D.23905 = (unsigned char) D.23904;
      item->has_target_code = D.23905;
      item->is_equals = 1;
      D.23906 = end + -1;
      if (D.23906 > i) goto <D.23907>; else goto <D.23908>;
      <D.23907>:
      D.23896 = out_array->len;
      D.23909 = D.23896 + 1;
      D.23910 = (int) D.23909;
      item->check_target_idx = D.23910;
      goto <D.23911>;
      <D.23908>:
      item->check_target_idx = 0;
      <D.23911>:
      monoeg_g_ptr_array_add (out_array, item);
    }
    i = i + 1;
    <D.21467>:
    if (i < end) goto <D.21466>; else goto <D.21468>;
    <D.21468>:
  }
  goto <D.23912>;
  <D.23898>:
  {
    int middle;
    struct MonoIMTCheckItem * item;

    D.23913 = count / 2;
    middle = D.23913 + start;
    item = monoeg_malloc0 (28);
    middle.58 = (unsigned int) middle;
    D.23915 = middle.58 * 4;
    D.23916 = sorted_array + D.23915;
    D.23917 = *D.23916;
    D.23918 = D.23917->key;
    item->key = D.23918;
    item->is_equals = 0;
    monoeg_g_ptr_array_add (out_array, item);
    imt_emit_ir (sorted_array, start, middle, out_array);
    D.23919 = imt_emit_ir (sorted_array, middle, end, out_array);
    item->check_target_idx = D.23919;
  }
  <D.23912>:
  D.23920 = chunk_start;
  return D.23920;
}


mono_method_alloc_generic_virtual_thunk (struct MonoDomain * domain, int size)
{
  unsigned int size.59;
  unsigned int D.23923;
  struct MonoThunkFreeList * * D.23926;
  unsigned int i.60;
  unsigned int D.23928;
  struct MonoThunkFreeList * D.23929;
  unsigned int D.23930;
  unsigned int size.61;
  struct _MonoThunkFreeList * D.23934;
  void * D.23935;
  struct MonoThunkFreeList * * D.23936;
  unsigned int D.23939;
  _Bool D.23940;
  long int D.23941;
  long int D.23942;
  struct _MonoThunkFreeList * D.23945;
  int inited.62;
  int generic_virtual_thunks_size.63;
  int generic_virtual_thunks_size.64;
  union mono_mutex_t * D.23951;
  _Bool D.23954;
  long int D.23955;
  long int D.23956;
  struct GHashTable * D.23959;
  struct GHashTable * D.23962;
  _Bool D.23965;
  long int D.23966;
  long int D.23967;
  static gboolean inited = 0;
  static int generic_virtual_thunks_size = 0;
  guint32 * p;
  int i;
  struct MonoThunkFreeList * * l;

  init_thunk_free_lists (domain);
  size.59 = (unsigned int) size;
  D.23923 = size.59 + 4;
  size = (int) D.23923;
  size.59 = (unsigned int) size;
  if (size.59 <= 11) goto <D.23924>; else goto <D.23925>;
  <D.23924>:
  size = 12;
  <D.23925>:
  i = list_index_for_size (size);
  D.23926 = domain->thunk_free_lists;
  i.60 = (unsigned int) i;
  D.23928 = i.60 * 4;
  l = D.23926 + D.23928;
  goto <D.21588>;
  <D.21587>:
  D.23929 = *l;
  D.23930 = D.23929->size;
  size.61 = (unsigned int) size;
  if (D.23930 >= size.61) goto <D.23932>; else goto <D.23933>;
  <D.23932>:
  {
    struct MonoThunkFreeList * item;

    item = *l;
    D.23934 = item->next;
    *l = D.23934;
    D.23935 = item + 4;
    return D.23935;
  }
  <D.23933>:
  D.23929 = *l;
  l = &D.23929->next;
  <D.21588>:
  D.23929 = *l;
  if (D.23929 != 0B) goto <D.21587>; else goto <D.21589>;
  <D.21589>:
  goto <D.21591>;
  <D.21592>:
  {
    struct MonoThunkFreeList * item;

    D.23926 = domain->thunk_free_lists;
    i.60 = (unsigned int) i;
    D.23928 = i.60 * 4;
    D.23936 = D.23926 + D.23928;
    item = *D.23936;
    if (item == 0B) goto <D.23937>; else goto <D.23938>;
    <D.23937>:
    // predicted unlikely by continue predictor.
    goto <D.21591>;
    <D.23938>:
    D.23939 = item->size;
    size.61 = (unsigned int) size;
    D.23940 = D.23939 <= size.61;
    D.23941 = (long int) D.23940;
    D.23942 = __builtin_expect (D.23941, 0);
    if (D.23942 != 0) goto <D.23943>; else goto <D.23944>;
    <D.23943>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 1550, "item->size > size");
    <D.23944>:
    D.23926 = domain->thunk_free_lists;
    i.60 = (unsigned int) i;
    D.23928 = i.60 * 4;
    D.23936 = D.23926 + D.23928;
    D.23945 = item->next;
    *D.23936 = D.23945;
    D.23935 = item + 4;
    return D.23935;
  }
  <D.21591>:
  i = i + 1;
  if (i <= 11) goto <D.21592>; else goto <D.21593>;
  <D.21593>:
  inited.62 = inited;
  if (inited.62 == 0) goto <D.23947>; else goto <D.23948>;
  <D.23947>:
  mono_counters_register ("Generic virtual thunk bytes", 2048, &generic_virtual_thunks_size);
  inited = 1;
  <D.23948>:
  generic_virtual_thunks_size.63 = generic_virtual_thunks_size;
  generic_virtual_thunks_size.64 = generic_virtual_thunks_size.63 + size;
  generic_virtual_thunks_size = generic_virtual_thunks_size.64;
  p = mono_domain_code_reserve (domain, size);
  size.61 = (unsigned int) size;
  *p = size.61;
  {
    int ret;

    D.23951 = &domain->lock.mutex;
    ret = pthread_mutex_lock (D.23951);
    if (ret != 0) goto <D.23952>; else goto <D.23953>;
    <D.23952>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
    <D.23953>:
    D.23954 = ret != 0;
    D.23955 = (long int) D.23954;
    D.23956 = __builtin_expect (D.23955, 0);
    if (D.23956 != 0) goto <D.23957>; else goto <D.23958>;
    <D.23957>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 1566, "ret == 0");
    <D.23958>:
  }
  D.23959 = domain->generic_virtual_thunks;
  if (D.23959 == 0B) goto <D.23960>; else goto <D.23961>;
  <D.23960>:
  D.23962 = monoeg_g_hash_table_new (0B, 0B);
  domain->generic_virtual_thunks = D.23962;
  <D.23961>:
  D.23959 = domain->generic_virtual_thunks;
  monoeg_g_hash_table_insert_replace (D.23959, p, p, 0);
  {
    int ret;

    D.23951 = &domain->lock.mutex;
    ret = pthread_mutex_unlock (D.23951);
    if (ret != 0) goto <D.23963>; else goto <D.23964>;
    <D.23963>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.23964>:
    D.23965 = ret != 0;
    D.23966 = (long int) D.23965;
    D.23967 = __builtin_expect (D.23966, 0);
    if (D.23967 != 0) goto <D.23968>; else goto <D.23969>;
    <D.23968>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 1570, "ret == 0");
    <D.23969>:
  }
  D.23935 = p + 4;
  return D.23935;
}


init_thunk_free_lists (struct MonoDomain * domain)
{
  struct MonoThunkFreeList * * D.23971;
  void * D.23974;

  D.23971 = domain->thunk_free_lists;
  if (D.23971 != 0B) goto <D.23972>; else goto <D.23973>;
  <D.23972>:
  return;
  <D.23973>:
  D.23974 = mono_domain_alloc0 (domain, 48);
  domain->thunk_free_lists = D.23974;
}


list_index_for_size (int item_size)
{
  _Bool D.23976;
  _Bool D.23977;
  _Bool D.23978;
  int D.23979;
  int i;
  int size;

  i = 2;
  size = 64;
  goto <D.21575>;
  <D.21574>:
  i = i + 1;
  size = size << 1;
  <D.21575>:
  D.23976 = item_size > size;
  D.23977 = i <= 10;
  D.23978 = D.23976 & D.23977;
  if (D.23978 != 0) goto <D.21574>; else goto <D.21576>;
  <D.21576>:
  D.23979 = i;
  return D.23979;
}


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.23981;
  _Bool D.23984;
  long int D.23985;
  long int D.23986;
  struct GHashTable * D.23989;
  struct GHashTable * D.23992;
  struct MonoMethod * D.23993;
  void * D.23997;
  int inited.65;
  int num_added.66;
  int num_added.67;
  int D.24003;
  int D.24004;
  int vtable_slot.68;
  int vtable.69;
  int D.24011;
  void * (*<T2f17>) (int) D.24012;
  void * iftmp.70;
  void * (*<T2f17>) (int) D.24015;
  void *[0:] * D.24018;
  int D.24019;
  int D.24020;
  int D.24021;
  void * (*<T314f>) (struct MonoVTable *, struct MonoDomain *, struct MonoIMTCheckItem * *, int, void *) imt_thunk_builder.71;
  void * * D.24024;
  unsigned int D.24025;
  int D.24026;
  void * D.24027;
  unsigned int i.72;
  unsigned int D.24029;
  void * * D.24030;
  void * D.24031;
  unsigned int i.73;
  _Bool D.24033;
  _Bool D.24034;
  _Bool D.24035;
  _Bool D.24040;
  long int D.24041;
  long int D.24042;
  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.23981 = &domain->lock.mutex;
    ret = pthread_mutex_lock (D.23981);
    if (ret != 0) goto <D.23982>; else goto <D.23983>;
    <D.23982>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
    <D.23983>:
    D.23984 = ret != 0;
    D.23985 = (long int) D.23984;
    D.23986 = __builtin_expect (D.23985, 0);
    if (D.23986 != 0) goto <D.23987>; else goto <D.23988>;
    <D.23987>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 1699, "ret == 0");
    <D.23988>:
  }
  D.23989 = domain->generic_virtual_cases;
  if (D.23989 == 0B) goto <D.23990>; else goto <D.23991>;
  <D.23990>:
  D.23992 = monoeg_g_hash_table_new (mono_aligned_addr_hash, 0B);
  domain->generic_virtual_cases = D.23992;
  <D.23991>:
  D.23989 = domain->generic_virtual_cases;
  list = monoeg_g_hash_table_lookup (D.23989, vtable_slot);
  gvc = list;
  goto <D.21647>;
  <D.21646>:
  D.23993 = gvc->method;
  if (D.23993 == method) goto <D.21645>; else goto <D.23994>;
  <D.23994>:
  gvc = gvc->next;
  <D.21647>:
  if (gvc != 0B) goto <D.21646>; else goto <D.21645>;
  <D.21645>:
  if (gvc == 0B) goto <D.23995>; else goto <D.23996>;
  <D.23995>:
  gvc = mono_domain_alloc (domain, 16);
  gvc->method = method;
  gvc->code = code;
  gvc->count = 0;
  D.23989 = domain->generic_virtual_cases;
  D.23997 = monoeg_g_hash_table_lookup (D.23989, vtable_slot);
  gvc->next = D.23997;
  D.23989 = domain->generic_virtual_cases;
  monoeg_g_hash_table_insert_replace (D.23989, vtable_slot, gvc, 0);
  inited.65 = inited;
  if (inited.65 == 0) goto <D.23999>; else goto <D.24000>;
  <D.23999>:
  mono_counters_register ("Generic virtual cases", 2048, &num_added);
  inited = 1;
  <D.24000>:
  num_added.66 = num_added;
  num_added.67 = num_added.66 + 1;
  num_added = num_added.67;
  <D.23996>:
  D.24003 = gvc->count;
  D.24004 = D.24003 + 1;
  gvc->count = D.24004;
  D.24003 = gvc->count;
  if (D.24003 == 10) goto <D.24005>; else goto <D.24006>;
  <D.24005>:
  {
    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.24007>; else goto <D.24008>;
    <D.24007>:
    {
      int displacement;
      int imt_slot;

      vtable_slot.68 = (int) vtable_slot;
      vtable.69 = (int) vtable;
      D.24011 = vtable_slot.68 - vtable.69;
      displacement = D.24011 /[ex] 4;
      imt_slot = displacement + 19;
      D.24012 = callbacks.get_imt_trampoline;
      imt_trampoline = D.24012 (imt_slot);
      *vtable_slot = imt_trampoline;
    }
    goto <D.24013>;
    <D.24008>:
    D.24015 = callbacks.get_vtable_trampoline;
    if (D.24015 != 0B) goto <D.24016>; else goto <D.24017>;
    <D.24016>:
    D.24015 = callbacks.get_vtable_trampoline;
    vtable_slot.68 = (int) vtable_slot;
    D.24018 = &vtable->vtable;
    D.24019 = (int) D.24018;
    D.24020 = vtable_slot.68 - D.24019;
    D.24021 = D.24020 /[ex] 4;
    iftmp.70 = D.24015 (D.24021);
    goto <D.24022>;
    <D.24017>:
    iftmp.70 = 0B;
    <D.24022>:
    vtable_trampoline = iftmp.70;
    entries = get_generic_virtual_entries (domain, vtable_slot);
    sorted = imt_sort_slot_entries (entries);
    imt_thunk_builder.71 = imt_thunk_builder;
    D.24024 = sorted->pdata;
    D.24025 = sorted->len;
    D.24026 = (int) D.24025;
    D.24027 = imt_thunk_builder.71 (0B, domain, D.24024, D.24026, vtable_trampoline);
    *vtable_slot = D.24027;
    goto <D.21655>;
    <D.21654>:
    {
      struct MonoImtBuilderEntry * next;

      next = entries->next;
      monoeg_g_free (entries);
      entries = next;
    }
    <D.21655>:
    if (entries != 0B) goto <D.21654>; else goto <D.21656>;
    <D.21656>:
    i = 0;
    goto <D.21658>;
    <D.21657>:
    D.24024 = sorted->pdata;
    i.72 = (unsigned int) i;
    D.24029 = i.72 * 4;
    D.24030 = D.24024 + D.24029;
    D.24031 = *D.24030;
    monoeg_g_free (D.24031);
    i = i + 1;
    <D.21658>:
    i.73 = (unsigned int) i;
    D.24025 = sorted->len;
    if (i.73 < D.24025) goto <D.21657>; else goto <D.21659>;
    <D.21659>:
    monoeg_g_ptr_array_free (sorted, 1);
    <D.24013>:
    D.24033 = old_thunk != vtable_trampoline;
    D.24034 = old_thunk != imt_trampoline;
    D.24035 = D.24033 & D.24034;
    if (D.24035 != 0) goto <D.24036>; else goto <D.24037>;
    <D.24036>:
    invalidate_generic_virtual_thunk (domain, old_thunk);
    <D.24037>:
  }
  <D.24006>:
  {
    int ret;

    D.23981 = &domain->lock.mutex;
    ret = pthread_mutex_unlock (D.23981);
    if (ret != 0) goto <D.24038>; else goto <D.24039>;
    <D.24038>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.24039>:
    D.24040 = ret != 0;
    D.24041 = (long int) D.24040;
    D.24042 = __builtin_expect (D.24041, 0);
    if (D.24042 != 0) goto <D.24043>; else goto <D.24044>;
    <D.24043>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 1770, "ret == 0");
    <D.24044>:
  }
}


invalidate_generic_virtual_thunk (struct MonoDomain * domain, void * code)
{
  union mono_mutex_t * D.24045;
  _Bool D.24048;
  long int D.24049;
  long int D.24050;
  struct GHashTable * D.24053;
  struct GHashTable * D.24056;
  void * D.24057;
  _Bool D.24062;
  long int D.24063;
  long int D.24064;
  struct MonoThunkFreeList * * D.24069;
  struct _MonoThunkFreeList * D.24070;
  struct MonoThunkFreeList * D.24071;
  int D.24072;
  unsigned int D.24073;
  int D.24074;
  unsigned int i.74;
  unsigned int D.24076;
  struct MonoThunkFreeList * * D.24077;
  struct MonoThunkFreeList * D.24078;
  int D.24080;
  struct MonoThunkFreeList * * D.24081;
  struct MonoThunkFreeList * D.24082;
  struct _MonoThunkFreeList * D.24085;
  int D.24086;
  _Bool D.24088;
  long int D.24089;
  long int D.24090;
  guint32 * p;
  struct MonoThunkFreeList * l;
  gboolean found;

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

    D.24045 = &domain->lock.mutex;
    ret = pthread_mutex_lock (D.24045);
    if (ret != 0) goto <D.24046>; else goto <D.24047>;
    <D.24046>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
    <D.24047>:
    D.24048 = ret != 0;
    D.24049 = (long int) D.24048;
    D.24050 = __builtin_expect (D.24049, 0);
    if (D.24050 != 0) goto <D.24051>; else goto <D.24052>;
    <D.24051>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 1585, "ret == 0");
    <D.24052>:
  }
  D.24053 = domain->generic_virtual_thunks;
  if (D.24053 == 0B) goto <D.24054>; else goto <D.24055>;
  <D.24054>:
  D.24056 = monoeg_g_hash_table_new (0B, 0B);
  domain->generic_virtual_thunks = D.24056;
  <D.24055>:
  D.24053 = domain->generic_virtual_thunks;
  D.24057 = monoeg_g_hash_table_lookup (D.24053, l);
  if (D.24057 != 0B) goto <D.24058>; else goto <D.24059>;
  <D.24058>:
  found = 1;
  <D.24059>:
  {
    int ret;

    D.24045 = &domain->lock.mutex;
    ret = pthread_mutex_unlock (D.24045);
    if (ret != 0) goto <D.24060>; else goto <D.24061>;
    <D.24060>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.24061>:
    D.24062 = ret != 0;
    D.24063 = (long int) D.24062;
    D.24064 = __builtin_expect (D.24063, 0);
    if (D.24064 != 0) goto <D.24065>; else goto <D.24066>;
    <D.24065>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 1590, "ret == 0");
    <D.24066>:
  }
  if (found == 0) goto <D.24067>; else goto <D.24068>;
  <D.24067>:
  return;
  <D.24068>:
  init_thunk_free_lists (domain);
  goto <D.21609>;
  <D.21608>:
  {
    struct MonoThunkFreeList * item;
    int length;
    int i;

    D.24069 = domain->thunk_free_lists;
    item = *D.24069;
    length = item->length;
    D.24069 = domain->thunk_free_lists;
    D.24070 = item->next;
    *D.24069 = D.24070;
    D.24069 = domain->thunk_free_lists;
    D.24071 = *D.24069;
    D.24072 = length + -1;
    D.24071->length = D.24072;
    D.24073 = item->size;
    D.24074 = (int) D.24073;
    i = list_index_for_size (D.24074);
    D.24069 = domain->thunk_free_lists;
    i.74 = (unsigned int) i;
    D.24076 = i.74 * 4;
    D.24077 = D.24069 + D.24076;
    D.24078 = *D.24077;
    item->next = D.24078;
    D.24069 = domain->thunk_free_lists;
    i.74 = (unsigned int) i;
    D.24076 = i.74 * 4;
    D.24077 = D.24069 + D.24076;
    *D.24077 = item;
  }
  <D.21609>:
  D.24069 = domain->thunk_free_lists;
  D.24071 = *D.24069;
  if (D.24071 != 0B) goto <D.24079>; else goto <D.21610>;
  <D.24079>:
  D.24069 = domain->thunk_free_lists;
  D.24071 = *D.24069;
  D.24080 = D.24071->length;
  if (D.24080 > 49) goto <D.21608>; else goto <D.21610>;
  <D.21610>:
  l->next = 0B;
  D.24069 = domain->thunk_free_lists;
  D.24081 = D.24069 + 4;
  D.24082 = *D.24081;
  if (D.24082 != 0B) goto <D.24083>; else goto <D.24084>;
  <D.24083>:
  D.24069 = domain->thunk_free_lists;
  D.24081 = D.24069 + 4;
  D.24069 = domain->thunk_free_lists;
  D.24081 = D.24069 + 4;
  D.24082 = *D.24081;
  D.24082->next = l;
  D.24085 = D.24082->next;
  *D.24081 = D.24085;
  D.24069 = domain->thunk_free_lists;
  D.24071 = *D.24069;
  D.24080 = D.24071->length;
  D.24086 = D.24080 + 1;
  D.24071->length = D.24086;
  goto <D.24087>;
  <D.24084>:
  D.24069 = domain->thunk_free_lists;
  D.24071 = *D.24069;
  D.24088 = D.24071 != 0B;
  D.24089 = (long int) D.24088;
  D.24090 = __builtin_expect (D.24089, 0);
  if (D.24090 != 0) goto <D.24091>; else goto <D.24092>;
  <D.24091>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 1618, "!domain->thunk_free_lists [0]");
  <D.24092>:
  D.24069 = domain->thunk_free_lists;
  D.24069 = domain->thunk_free_lists;
  D.24081 = D.24069 + 4;
  *D.24081 = l;
  D.24082 = *D.24081;
  *D.24069 = D.24082;
  D.24069 = domain->thunk_free_lists;
  D.24071 = *D.24069;
  D.24071->length = 1;
  <D.24087>:
}


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

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


mono_class_vtable_full (struct MonoDomain * domain, struct MonoClass * class, gboolean raise_on_error)
{
  _Bool D.24096;
  long int D.24097;
  long int D.24098;
  unsigned char D.24101;
  struct MonoException * D.24106;
  struct MonoVTable * D.24107;
  short unsigned int D.24110;
  int D.24111;
  int D.24112;
  struct MonoVTable * D.24115;
  struct MonoClassRuntimeInfo * runtime_info;

  D.24096 = class == 0B;
  D.24097 = (long int) D.24096;
  D.24098 = __builtin_expect (D.24097, 0);
  if (D.24098 != 0) goto <D.24099>; else goto <D.24100>;
  <D.24099>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 1804, "class");
  <D.24100>:
  D.24101 = class->exception_type;
  if (D.24101 != 0) goto <D.24102>; else goto <D.24103>;
  <D.24102>:
  if (raise_on_error != 0) goto <D.24104>; else goto <D.24105>;
  <D.24104>:
  D.24106 = mono_class_get_exception_for_failure (class);
  mono_raise_exception (D.24106);
  <D.24105>:
  D.24107 = 0B;
  return D.24107;
  <D.24103>:
  runtime_info = class->runtime_info;
  if (runtime_info != 0B) goto <D.24108>; else goto <D.24109>;
  <D.24108>:
  D.24110 = runtime_info->max_domain;
  D.24111 = (int) D.24110;
  D.24112 = domain->domain_id;
  if (D.24111 >= D.24112) goto <D.24113>; else goto <D.24114>;
  <D.24113>:
  D.24112 = domain->domain_id;
  D.24115 = runtime_info->domain_vtables[D.24112];
  if (D.24115 != 0B) goto <D.24116>; else goto <D.24117>;
  <D.24116>:
  D.24112 = domain->domain_id;
  D.24107 = runtime_info->domain_vtables[D.24112];
  return D.24107;
  <D.24117>:
  <D.24114>:
  <D.24109>:
  D.24107 = mono_class_create_runtime_vtable (domain, class, raise_on_error);
  return D.24107;
}


mono_class_create_runtime_vtable (struct MonoDomain * domain, struct MonoClass * class, gboolean raise_on_error)
{
  union mono_mutex_t * D.24119;
  _Bool D.24122;
  long int D.24123;
  long int D.24124;
  short unsigned int D.24129;
  int D.24130;
  int D.24131;
  struct MonoVTable * D.24134;
  _Bool D.24139;
  long int D.24140;
  long int D.24141;
  struct MonoVTable * D.24144;
  unsigned char D.24147;
  unsigned char D.24148;
  unsigned char D.24150;
  int D.24153;
  _Bool D.24157;
  long int D.24158;
  long int D.24159;
  struct MonoException * D.24164;
  unsigned char D.24165;
  _Bool D.24166;
  _Bool D.24167;
  _Bool D.24168;
  unsigned char D.24171;
  unsigned char D.24172;
  unsigned char D.24175;
  int D.24178;
  _Bool D.24187;
  long int D.24188;
  long int D.24189;
  struct MonoException * D.24194;
  int D.24195;
  struct MonoGenericClass * D.24198;
  struct MonoMethod * * D.24201;
  _Bool D.24208;
  long int D.24209;
  long int D.24210;
  struct MonoException * D.24215;
  int D.24216;
  void * (*<T314f>) (struct MonoVTable *, struct MonoDomain *, struct MonoIMTCheckItem * *, int, void *) imt_thunk_builder.75;
  unsigned int vtable_slots.76;
  unsigned int D.24223;
  short unsigned int D.24224;
  long unsigned int D.24227;
  long unsigned int D.24228;
  long unsigned int D.24229;
  long unsigned int D.24230;
  short unsigned int D.24232;
  unsigned int D.24233;
  unsigned int D.24234;
  unsigned int D.24235;
  long unsigned int D.24236;
  long unsigned int D.24237;
  long unsigned int D.24238;
  long unsigned int D.24239;
  sizetype imt_table_bytes.77;
  sizetype D.24244;
  sizetype D.24245;
  sizetype D.24246;
  unsigned char D.24247;
  void * D.24248;
  unsigned int D.24249;
  int D.24250;
  _Bool D.24251;
  long int D.24252;
  long int D.24253;
  unsigned char D.24256;
  <unnamed-unsigned:4> D.24257;
  unsigned char D.24260;
  unsigned char D.24261;
  int max_set.78;
  int D.24265;
  void * D.24266;
  void * D.24267;
  void * D.24271;
  long unsigned int D.24272;
  long unsigned int D.24273;
  struct MonoType * D.24274;
  short unsigned int D.24275;
  int D.24276;
  int D.24277;
  int D.24280;
  int D.21718;
  int iftmp.79;
  int D.21717;
  const char[9] * D.24286;
  unsigned char D.24287;
  int D.24288;
  unsigned char D.24289;
  int D.24290;
  _Bool D.24291;
  _Bool D.24292;
  _Bool D.24293;
  const unsigned char * D.24296;
  unsigned char D.24297;
  int D.24298;
  const unsigned char * D.24299;
  unsigned char D.24300;
  int D.24301;
  _Bool D.24302;
  _Bool D.24303;
  const unsigned char * D.24306;
  unsigned char D.24307;
  int D.24308;
  const unsigned char * D.24309;
  unsigned char D.24310;
  int D.24311;
  _Bool D.24312;
  _Bool D.24313;
  const unsigned char * D.24316;
  unsigned char D.24317;
  int D.24318;
  const unsigned char * D.24319;
  unsigned char D.24320;
  int D.24321;
  const char * D.24323;
  int D.24326;
  int iftmp.80;
  unsigned char D.24330;
  int D.24336;
  int D.24340;
  int max_set.81;
  int D.24345;
  unsigned int special_static.82;
  int align.83;
  unsigned int align.84;
  struct GHashTable * D.24349;
  struct GHashTable * D.24352;
  void * offset.85;
  int D.24356;
  signed short D.24359;
  _Bool D.24360;
  long int D.24361;
  long int D.24362;
  void * D.24365;
  int D.24366;
  sizetype D.24367;
  unsigned char D.24370;
  unsigned char D.24371;
  int D.24374;
  unsigned int D.24375;
  unsigned char D.24377;
  _Bool D.24378;
  _Bool D.24379;
  _Bool D.24380;
  int D.24381;
  _Bool D.24382;
  long int D.24383;
  long int D.24384;
  char D.24387;
  guint8 * D.24388;
  struct MonoClass * * D.24391;
  unsigned int i.86;
  unsigned int D.24393;
  struct MonoClass * * D.24394;
  struct MonoClass * D.24395;
  short unsigned int D.24396;
  guint16 * D.24397;
  unsigned int D.24398;
  guint16 * D.24399;
  short unsigned int D.24400;
  int D.24401;
  int D.24402;
  unsigned int D.24403;
  unsigned int D.24404;
  void * * D.24405;
  void * * D.24406;
  int D.24407;
  void * (*<T2f17>) (int) D.24408;
  void * D.24411;
  struct MonoMethod * * D.24413;
  void * (*<T2796>) (struct MonoMethod *) arch_create_jit_trampoline.87;
  void * D.24417;
  void * (*<T2f17>) (int) D.24422;
  void * * D.24425;
  void * D.24426;
  struct MonoClass * D.24428;
  struct MonoType * D.24431;
  struct MonoReflectionType * D.24432;
  void * D.24433;
  struct MonoClass * D.24434;
  int D.24437;
  void * * D.24442;
  void * D.24443;
  unsigned char D.24444;
  signed char D.24445;
  _Bool D.24446;
  struct GPtrArray * D.24447;
  short unsigned int D.24451;
  int D.24452;
  int D.24456;
  struct MonoImage * D.24457;
  unsigned int new_size.88;
  unsigned int D.24459;
  unsigned int D.24460;
  short unsigned int D.24461;
  short unsigned int D.24462;
  struct MonoVTable *[0:] * D.24465;
  struct MonoVTable *[0:] * D.24466;
  int D.24467;
  unsigned int D.24468;
  unsigned int D.24469;
  struct MonoReflectionType * D.24472;
  struct MonoClass * D.24473;
  int D.24476;
  void * D.24481;
  _Bool D.24484;
  long int D.24485;
  long int D.24486;
  int D.24489;
  struct MonoException * D.24496;
  struct MonoClass * D.24497;
  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.24119 = &domain->lock.mutex;
        ret = pthread_mutex_lock (D.24119);
        if (ret != 0) goto <D.24120>; else goto <D.24121>;
        <D.24120>:
        monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
        <D.24121>:
        D.24122 = ret != 0;
        D.24123 = (long int) D.24122;
        D.24124 = __builtin_expect (D.24123, 0);
        if (D.24124 != 0) goto <D.24125>; else goto <D.24126>;
        <D.24125>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 1856, "ret == 0");
        <D.24126>:
      }
      runtime_info = class->runtime_info;
      if (runtime_info != 0B) goto <D.24127>; else goto <D.24128>;
      <D.24127>:
      D.24129 = runtime_info->max_domain;
      D.24130 = (int) D.24129;
      D.24131 = domain->domain_id;
      if (D.24130 >= D.24131) goto <D.24132>; else goto <D.24133>;
      <D.24132>:
      D.24131 = domain->domain_id;
      D.24134 = runtime_info->domain_vtables[D.24131];
      if (D.24134 != 0B) goto <D.24135>; else goto <D.24136>;
      <D.24135>:
      {
        int ret;

        D.24119 = &domain->lock.mutex;
        ret = pthread_mutex_unlock (D.24119);
        if (ret != 0) goto <D.24137>; else goto <D.24138>;
        <D.24137>:
        monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
        <D.24138>:
        D.24139 = ret != 0;
        D.24140 = (long int) D.24139;
        D.24141 = __builtin_expect (D.24140, 0);
        if (D.24141 != 0) goto <D.24142>; else goto <D.24143>;
        <D.24142>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 1859, "ret == 0");
        <D.24143>:
      }
      mono_loader_unlock ();
      D.24131 = domain->domain_id;
      D.24144 = runtime_info->domain_vtables[D.24131];
      return D.24144;
      <D.24136>:
      <D.24133>:
      <D.24128>:
      D.24147 = BIT_FIELD_REF <*class, 8, 160>;
      D.24148 = D.24147 & 1;
      if (D.24148 == 0) goto <D.24145>; else goto <D.24149>;
      <D.24149>:
      D.24150 = class->exception_type;
      if (D.24150 != 0) goto <D.24145>; else goto <D.24146>;
      <D.24145>:
      D.24153 = mono_class_init (class);
      if (D.24153 == 0) goto <D.24151>; else goto <D.24154>;
      <D.24154>:
      D.24150 = class->exception_type;
      if (D.24150 != 0) goto <D.24151>; else goto <D.24152>;
      <D.24151>:
      {
        int ret;

        D.24119 = &domain->lock.mutex;
        ret = pthread_mutex_unlock (D.24119);
        if (ret != 0) goto <D.24155>; else goto <D.24156>;
        <D.24155>:
        monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
        <D.24156>:
        D.24157 = ret != 0;
        D.24158 = (long int) D.24157;
        D.24159 = __builtin_expect (D.24158, 0);
        if (D.24159 != 0) goto <D.24160>; else goto <D.24161>;
        <D.24160>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 1865, "ret == 0");
        <D.24161>:
      }
      mono_loader_unlock ();
      if (raise_on_error != 0) goto <D.24162>; else goto <D.24163>;
      <D.24162>:
      D.24164 = mono_class_get_exception_for_failure (class);
      mono_raise_exception (D.24164);
      <D.24163>:
      D.24144 = 0B;
      return D.24144;
      <D.24152>:
      <D.24146>:
      D.24165 = class->byval_arg.type;
      D.24166 = D.24165 == 20;
      D.24167 = D.24165 == 29;
      D.24168 = D.24166 | D.24167;
      if (D.24168 != 0) goto <D.24169>; else goto <D.24170>;
      <D.24169>:
      {
        struct MonoClass * element_class;

        element_class = class->element_class;
        D.24171 = BIT_FIELD_REF <*element_class, 8, 160>;
        D.24172 = D.24171 & 1;
        if (D.24172 == 0) goto <D.24173>; else goto <D.24174>;
        <D.24173>:
        mono_class_init (element_class);
        <D.24174>:
        D.24175 = element_class->exception_type;
        if (D.24175 == 0) goto <D.24176>; else goto <D.24177>;
        <D.24176>:
        D.24178 = element_class->vtable_size;
        if (D.24178 == 0) goto <D.24179>; else goto <D.24180>;
        <D.24179>:
        mono_class_setup_vtable (element_class);
        <D.24180>:
        <D.24177>:
        D.24175 = element_class->exception_type;
        if (D.24175 != 0) goto <D.24181>; else goto <D.24182>;
        <D.24181>:
        D.24150 = class->exception_type;
        if (D.24150 == 0) goto <D.24183>; else goto <D.24184>;
        <D.24183>:
        mono_class_set_failure (class, 7, 0B);
        <D.24184>:
        {
          int ret;

          D.24119 = &domain->lock.mutex;
          ret = pthread_mutex_unlock (D.24119);
          if (ret != 0) goto <D.24185>; else goto <D.24186>;
          <D.24185>:
          monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
          <D.24186>:
          D.24187 = ret != 0;
          D.24188 = (long int) D.24187;
          D.24189 = __builtin_expect (D.24188, 0);
          if (D.24189 != 0) goto <D.24190>; else goto <D.24191>;
          <D.24190>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 1887, "ret == 0");
          <D.24191>:
        }
        mono_loader_unlock ();
        if (raise_on_error != 0) goto <D.24192>; else goto <D.24193>;
        <D.24192>:
        D.24194 = mono_class_get_exception_for_failure (class);
        mono_raise_exception (D.24194);
        <D.24193>:
        D.24144 = 0B;
        return D.24144;
        <D.24182>:
      }
      <D.24170>:
      D.24195 = class->vtable_size;
      if (D.24195 == 0) goto <D.24196>; else goto <D.24197>;
      <D.24196>:
      mono_class_setup_vtable (class);
      <D.24197>:
      D.24198 = class->generic_class;
      if (D.24198 != 0B) goto <D.24199>; else goto <D.24200>;
      <D.24199>:
      D.24201 = class->vtable;
      if (D.24201 == 0B) goto <D.24202>; else goto <D.24203>;
      <D.24202>:
      mono_class_check_vtable_constraints (class, 0B);
      <D.24203>:
      <D.24200>:
      mono_class_has_finalizer (class);
      D.24150 = class->exception_type;
      if (D.24150 != 0) goto <D.24204>; else goto <D.24205>;
      <D.24204>:
      {
        int ret;

        D.24119 = &domain->lock.mutex;
        ret = pthread_mutex_unlock (D.24119);
        if (ret != 0) goto <D.24206>; else goto <D.24207>;
        <D.24206>:
        monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
        <D.24207>:
        D.24208 = ret != 0;
        D.24209 = (long int) D.24208;
        D.24210 = __builtin_expect (D.24209, 0);
        if (D.24210 != 0) goto <D.24211>; else goto <D.24212>;
        <D.24211>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 1909, "ret == 0");
        <D.24212>:
      }
      mono_loader_unlock ();
      if (raise_on_error != 0) goto <D.24213>; else goto <D.24214>;
      <D.24213>:
      D.24215 = mono_class_get_exception_for_failure (class);
      mono_raise_exception (D.24215);
      <D.24214>:
      D.24144 = 0B;
      return D.24144;
      <D.24205>:
      vtable_slots = class->vtable_size;
      D.24216 = mono_class_data_size (class);
      class_size = (guint32) D.24216;
      if (class_size != 0) goto <D.24217>; else goto <D.24218>;
      <D.24217>:
      vtable_slots = vtable_slots + 1;
      <D.24218>:
      imt_thunk_builder.75 = imt_thunk_builder;
      if (imt_thunk_builder.75 != 0B) goto <D.24220>; else goto <D.24221>;
      <D.24220>:
      vtable_slots.76 = (unsigned int) vtable_slots;
      D.24223 = vtable_slots.76 + 8;
      vtable_size = D.24223 * 4;
      D.24224 = class->interface_offsets_count;
      if (D.24224 != 0) goto <D.24225>; else goto <D.24226>;
      <D.24225>:
      imt_table_bytes = 76;
      vtable_size = vtable_size + 76;
      D.24227 = mono_stats.imt_number_of_tables;
      D.24228 = D.24227 + 1;
      mono_stats.imt_number_of_tables = D.24228;
      D.24229 = mono_stats.imt_tables_size;
      D.24230 = D.24229 + 76;
      mono_stats.imt_tables_size = D.24230;
      <D.24226>:
      goto <D.24231>;
      <D.24221>:
      D.24232 = class->max_interface_id;
      D.24233 = (unsigned int) D.24232;
      vtable_slots.76 = (unsigned int) vtable_slots;
      D.24234 = D.24233 + vtable_slots.76;
      D.24235 = D.24234 + 9;
      vtable_size = D.24235 * 4;
      <D.24231>:
      D.24236 = mono_stats.used_class_count;
      D.24237 = D.24236 + 1;
      mono_stats.used_class_count = D.24237;
      D.24238 = mono_stats.class_vtable_size;
      D.24239 = D.24238 + vtable_size;
      mono_stats.class_vtable_size = D.24239;
      interface_offsets = mono_domain_alloc0 (domain, vtable_size);
      imt_thunk_builder.75 = imt_thunk_builder;
      if (imt_thunk_builder.75 != 0B) goto <D.24240>; else goto <D.24241>;
      <D.24240>:
      imt_table_bytes.77 = (sizetype) imt_table_bytes;
      vt = interface_offsets + imt_table_bytes.77;
      goto <D.24243>;
      <D.24241>:
      D.24232 = class->max_interface_id;
      D.24244 = (sizetype) D.24232;
      D.24245 = D.24244 + 1;
      D.24246 = D.24245 * 4;
      vt = interface_offsets + D.24246;
      <D.24243>:
      vt->klass = class;
      D.24247 = class->rank;
      vt->rank = D.24247;
      vt->domain = domain;
      mono_class_compute_gc_descriptor (class);
      D.24248 = class->gc_descr;
      vt->gc_descr = D.24248;
      D.24249 = mono_gc_get_vtable_bits (class);
      gc_bits = (int) D.24249;
      D.24250 = gc_bits & -16;
      D.24251 = D.24250 != 0;
      D.24252 = (long int) D.24251;
      D.24253 = __builtin_expect (D.24252, 0);
      if (D.24253 != 0) goto <D.24254>; else goto <D.24255>;
      <D.24254>:
      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.24255>:
      D.24256 = (unsigned char) gc_bits;
      D.24257 = (<unnamed-unsigned:4>) D.24256;
      vt->gc_bits = D.24257;
      if (class_size != 0) goto <D.24258>; else goto <D.24259>;
      <D.24258>:
      D.24260 = BIT_FIELD_REF <*class, 8, 184>;
      D.24261 = D.24260 & 16;
      if (D.24261 != 0) goto <D.24262>; else goto <D.24263>;
      <D.24262>:
      {
        void * statics_gc_descr;
        int max_set;
        gsize default_bitmap[4];
        gsize * bitmap;

        try
          {
            max_set = 0;
            default_bitmap = {};
            bitmap = compute_class_bitmap (class, &default_bitmap, 128, 0, &max_set, 1);
            max_set.78 = max_set;
            D.24265 = max_set.78 + 1;
            statics_gc_descr = mono_gc_make_descr_from_bitmap (bitmap, D.24265);
            D.24195 = class->vtable_size;
            D.24266 = mono_gc_alloc_fixed (class_size, statics_gc_descr);
            vt->vtable[D.24195] = D.24266;
            D.24195 = class->vtable_size;
            D.24267 = vt->vtable[D.24195];
            mono_domain_add_class_static_data (domain, class, D.24267, 0B);
            if (&default_bitmap != bitmap) goto <D.24268>; else goto <D.24269>;
            <D.24268>:
            monoeg_g_free (bitmap);
            <D.24269>:
          }
        finally
          {
            max_set = {CLOBBER};
            default_bitmap = {CLOBBER};
          }
      }
      goto <D.24270>;
      <D.24263>:
      D.24195 = class->vtable_size;
      D.24271 = mono_domain_alloc0 (domain, class_size);
      vt->vtable[D.24195] = D.24271;
      <D.24270>:
      vt->has_static_fields = 1;
      D.24272 = mono_stats.class_static_data_size;
      D.24273 = D.24272 + class_size;
      mono_stats.class_static_data_size = D.24273;
      <D.24259>:
      cindex = 4294967295;
      iter = 0B;
      goto <D.21709>;
      <D.21730>:
      D.24274 = field->type;
      D.24275 = D.24274->attrs;
      D.24276 = (int) D.24275;
      D.24277 = D.24276 & 16;
      if (D.24277 == 0) goto <D.24278>; else goto <D.24279>;
      <D.24278>:
      // predicted unlikely by continue predictor.
      goto <D.21709>;
      <D.24279>:
      D.24274 = field->type;
      D.24275 = D.24274->attrs;
      D.24276 = (int) D.24275;
      D.24280 = D.24276 & 1536;
      if (D.24280 != 0) goto <D.24281>; else goto <D.24282>;
      <D.24281>:
      {
        size_t __s1_len;
        size_t __s2_len;

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

          __s2 = mono_field_get_name (field);
          D.24286 = "_Deleted";
          D.24287 = MEM[(const unsigned char *)D.24286];
          D.24288 = (int) D.24287;
          D.24289 = *__s2;
          D.24290 = (int) D.24289;
          __result = D.24288 - D.24290;
          {
            D.24291 = __s2_len != 0;
            D.24292 = __result == 0;
            D.24293 = D.24291 & D.24292;
            if (D.24293 != 0) goto <D.24294>; else goto <D.24295>;
            <D.24294>:
            D.24296 = &MEM[(void *)"_Deleted" + 1B];
            D.24297 = *D.24296;
            D.24298 = (int) D.24297;
            D.24299 = __s2 + 1;
            D.24300 = *D.24299;
            D.24301 = (int) D.24300;
            __result = D.24298 - D.24301;
            D.24302 = __s2_len > 1;
            D.24292 = __result == 0;
            D.24303 = D.24302 & D.24292;
            if (D.24303 != 0) goto <D.24304>; else goto <D.24305>;
            <D.24304>:
            D.24306 = &MEM[(void *)"_Deleted" + 2B];
            D.24307 = *D.24306;
            D.24308 = (int) D.24307;
            D.24309 = __s2 + 2;
            D.24310 = *D.24309;
            D.24311 = (int) D.24310;
            __result = D.24308 - D.24311;
            D.24312 = __s2_len > 2;
            D.24292 = __result == 0;
            D.24313 = D.24312 & D.24292;
            if (D.24313 != 0) goto <D.24314>; else goto <D.24315>;
            <D.24314>:
            D.24316 = &MEM[(void *)"_Deleted" + 3B];
            D.24317 = *D.24316;
            D.24318 = (int) D.24317;
            D.24319 = __s2 + 3;
            D.24320 = *D.24319;
            D.24321 = (int) D.24320;
            __result = D.24318 - D.24321;
            <D.24315>:
            <D.24305>:
            <D.24295>:
          }
          D.21717 = __result;
        }
        iftmp.79 = -D.21717;
        goto <D.24322>;
        <D.24285>:
        D.24323 = mono_field_get_name (field);
        iftmp.79 = __builtin_strcmp (D.24323, "_Deleted");
        <D.24322>:
        D.21718 = iftmp.79;
      }
      if (D.21718 == 0) goto <D.24324>; else goto <D.24325>;
      <D.24324>:
      // predicted unlikely by continue predictor.
      goto <D.21709>;
      <D.24325>:
      <D.24282>:
      D.24274 = field->type;
      D.24275 = D.24274->attrs;
      D.24276 = (int) D.24275;
      D.24326 = D.24276 & 64;
      if (D.24326 == 0) goto <D.24327>; else goto <D.24328>;
      <D.24327>:
      {
        gint32 special_static;

        D.24260 = BIT_FIELD_REF <*class, 8, 184>;
        D.24330 = D.24260 & 32;
        if (D.24330 == 0) goto <D.24331>; else goto <D.24332>;
        <D.24331>:
        iftmp.80 = field_is_special_static (class, field);
        goto <D.24333>;
        <D.24332>:
        iftmp.80 = 0;
        <D.24333>:
        special_static = iftmp.80;
        if (special_static != 0) goto <D.24334>; else goto <D.24335>;
        <D.24334>:
        {
          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.24274 = field->type;
              D.24336 = mono_type_is_reference (D.24274);
              if (D.24336 != 0) goto <D.24337>; else goto <D.24338>;
              <D.24337>:
              default_bitmap[0] = 1;
              numbits = 1;
              bitmap = &default_bitmap;
              goto <D.24339>;
              <D.24338>:
              D.24274 = field->type;
              D.24340 = mono_type_is_struct (D.24274);
              if (D.24340 != 0) goto <D.24341>; else goto <D.24342>;
              <D.24341>:
              D.24274 = field->type;
              fclass = mono_class_from_mono_type (D.24274);
              bitmap = compute_class_bitmap (fclass, &default_bitmap, 128, -2, &max_set, 0);
              max_set.81 = max_set;
              numbits = max_set.81 + 1;
              goto <D.24344>;
              <D.24342>:
              default_bitmap[0] = 0;
              numbits = 0;
              bitmap = &default_bitmap;
              <D.24344>:
              <D.24339>:
              D.24274 = field->type;
              D.24345 = mono_type_size (D.24274, &align);
              size = (guint32) D.24345;
              special_static.82 = (unsigned int) special_static;
              align.83 = align;
              align.84 = (unsigned int) align.83;
              offset = mono_alloc_special_static_data (special_static.82, size, align.84, bitmap, numbits);
              D.24349 = domain->special_static_fields;
              if (D.24349 == 0B) goto <D.24350>; else goto <D.24351>;
              <D.24350>:
              D.24352 = monoeg_g_hash_table_new (0B, 0B);
              domain->special_static_fields = D.24352;
              <D.24351>:
              D.24349 = domain->special_static_fields;
              offset.85 = (void *) offset;
              monoeg_g_hash_table_insert_replace (D.24349, field, offset.85, 0);
              if (&default_bitmap != bitmap) goto <D.24354>; else goto <D.24355>;
              <D.24354>:
              monoeg_g_free (bitmap);
              <D.24355>:
              field->offset = -1;
              // predicted unlikely by continue predictor.
              goto <D.21709>;
            }
          finally
            {
              align = {CLOBBER};
              default_bitmap = {CLOBBER};
              max_set = {CLOBBER};
            }
        }
        <D.24335>:
      }
      <D.24328>:
      D.24274 = field->type;
      D.24275 = D.24274->attrs;
      D.24276 = (int) D.24275;
      D.24356 = D.24276 & 256;
      if (D.24356 != 0) goto <D.24357>; else goto <D.24358>;
      <D.24357>:
      {
        struct MonoClass * fklass;
        const char * data;

        D.24274 = field->type;
        fklass = mono_class_from_mono_type (D.24274);
        data = mono_field_get_data (field);
        D.24274 = field->type;
        D.24275 = D.24274->attrs;
        D.24359 = (signed short) D.24275;
        D.24360 = D.24359 < 0;
        D.24361 = (long int) D.24360;
        D.24362 = __builtin_expect (D.24361, 0);
        if (D.24362 != 0) goto <D.24363>; else goto <D.24364>;
        <D.24363>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 2043, "!(field->type->attrs & FIELD_ATTRIBUTE_HAS_DEFAULT)");
        <D.24364>:
        D.24365 = mono_vtable_get_static_field_data (vt);
        D.24366 = field->offset;
        D.24367 = (sizetype) D.24366;
        t = D.24365 + D.24367;
        if (data == 0B) goto <D.24368>; else goto <D.24369>;
        <D.24368>:
        // predicted unlikely by continue predictor.
        goto <D.21709>;
        <D.24369>:
        D.24370 = BIT_FIELD_REF <*fklass, 8, 160>;
        D.24371 = D.24370 & 8;
        if (D.24371 != 0) goto <D.24372>; else goto <D.24373>;
        <D.24372>:
        D.24374 = mono_class_value_size (fklass, 0B);
        D.24375 = (unsigned int) D.24374;
        memcpy (t, data, D.24375);
        goto <D.24376>;
        <D.24373>:
        D.24377 = fklass->byval_arg.type;
        D.24378 = D.24377 != 15;
        D.24379 = D.24377 != 27;
        D.24380 = D.24378 & D.24379;
        D.24381 = (int) D.24380;
        D.24382 = D.24381 != 0;
        D.24383 = (long int) D.24382;
        D.24384 = __builtin_expect (D.24383, 0);
        if (D.24384 != 0) goto <D.24385>; else goto <D.24386>;
        <D.24385>:
        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.24386>:
        D.24387 = MEM[(char *)data];
        *t = D.24387;
        <D.24376>:
        // predicted unlikely by continue predictor.
        goto <D.21709>;
      }
      <D.24358>:
      <D.21709>:
      field = mono_class_get_fields (class, &iter);
      if (field != 0B) goto <D.21730>; else goto <D.21731>;
      <D.21731>:
      D.24232 = class->max_interface_id;
      vt->max_interface_id = D.24232;
      D.24388 = class->interface_bitmap;
      vt->interface_bitmap = D.24388;
      imt_thunk_builder.75 = imt_thunk_builder;
      if (imt_thunk_builder.75 == 0B) goto <D.24389>; else goto <D.24390>;
      <D.24389>:
      i = 0;
      goto <D.21735>;
      <D.21734>:
      {
        int interface_id;
        int slot;

        D.24391 = class->interfaces_packed;
        i.86 = (unsigned int) i;
        D.24393 = i.86 * 4;
        D.24394 = D.24391 + D.24393;
        D.24395 = *D.24394;
        D.24396 = D.24395->interface_id;
        interface_id = (int) D.24396;
        D.24397 = class->interface_offsets_packed;
        i.86 = (unsigned int) i;
        D.24398 = i.86 * 2;
        D.24399 = D.24397 + D.24398;
        D.24400 = *D.24399;
        slot = (int) D.24400;
        D.24232 = class->max_interface_id;
        D.24401 = (int) D.24232;
        D.24402 = D.24401 - interface_id;
        D.24403 = (unsigned int) D.24402;
        D.24404 = D.24403 * 4;
        D.24405 = interface_offsets + D.24404;
        D.24406 = &vt->vtable[slot];
        *D.24405 = D.24406;
      }
      i = i + 1;
      <D.21735>:
      D.24224 = class->interface_offsets_count;
      D.24407 = (int) D.24224;
      if (D.24407 > i) goto <D.21734>; else goto <D.21736>;
      <D.21736>:
      <D.24390>:
      D.24408 = callbacks.get_vtable_trampoline;
      if (D.24408 != 0B) goto <D.24409>; else goto <D.24410>;
      <D.24409>:
      i = 0;
      goto <D.21738>;
      <D.21737>:
      D.24408 = callbacks.get_vtable_trampoline;
      D.24411 = D.24408 (i);
      vt->vtable[i] = D.24411;
      i = i + 1;
      <D.21738>:
      D.24195 = class->vtable_size;
      if (D.24195 > i) goto <D.21737>; else goto <D.21739>;
      <D.21739>:
      goto <D.24412>;
      <D.24410>:
      mono_class_setup_vtable (class);
      i = 0;
      goto <D.21742>;
      <D.21741>:
      {
        struct MonoMethod * cm;

        D.24201 = class->vtable;
        i.86 = (unsigned int) i;
        D.24393 = i.86 * 4;
        D.24413 = D.24201 + D.24393;
        cm = *D.24413;
        if (cm != 0B) goto <D.24414>; else goto <D.24415>;
        <D.24414>:
        arch_create_jit_trampoline.87 = arch_create_jit_trampoline;
        D.24417 = arch_create_jit_trampoline.87 (cm);
        vt->vtable[i] = D.24417;
        <D.24415>:
      }
      i = i + 1;
      <D.21742>:
      D.24195 = class->vtable_size;
      if (D.24195 > i) goto <D.21741>; else goto <D.21743>;
      <D.21743>:
      <D.24412>:
      imt_thunk_builder.75 = imt_thunk_builder;
      if (imt_thunk_builder.75 != 0B) goto <D.24418>; else goto <D.24419>;
      <D.24418>:
      if (imt_table_bytes != 0) goto <D.24420>; else goto <D.24421>;
      <D.24420>:
      D.24422 = callbacks.get_imt_trampoline;
      if (D.24422 != 0B) goto <D.24423>; else goto <D.24424>;
      <D.24423>:
      i = 0;
      goto <D.21745>;
      <D.21744>:
      i.86 = (unsigned int) i;
      D.24393 = i.86 * 4;
      D.24425 = interface_offsets + D.24393;
      D.24422 = callbacks.get_imt_trampoline;
      D.24426 = D.24422 (i);
      *D.24425 = D.24426;
      i = i + 1;
      <D.21745>:
      if (i <= 18) goto <D.21744>; else goto <D.21746>;
      <D.21746>:
      goto <D.24427>;
      <D.24424>:
      build_imt (class, vt, domain, interface_offsets, 0B);
      <D.24427>:
      <D.24421>:
      <D.24419>:
      D.24428 = mono_defaults.monotype_class;
      if (D.24428 != class) goto <D.24429>; else goto <D.24430>;
      <D.24429>:
      D.24431 = &class->byval_arg;
      D.24432 = mono_type_get_object (domain, D.24431);
      vt->type = D.24432;
      D.24433 = vt->type;
      D.24434 = mono_object_get_class (D.24433);
      D.24428 = mono_defaults.monotype_class;
      if (D.24434 != D.24428) goto <D.24435>; else goto <D.24436>;
      <D.24435>:
      D.24437 = mono_gc_is_moving ();
      if (D.24437 != 0) goto <D.24438>; else goto <D.24439>;
      <D.24438>:
      if (0 != 0) goto <D.24440>; else goto <D.24441>;
      <D.24440>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 2114, "sizeof (vt->type) == sizeof (MonoObject*)");
      <D.24441>:
      D.24442 = &vt->type;
      D.24443 = mono_gc_make_root_descr_all_refs (1);
      mono_gc_register_root (D.24442, 4, D.24443);
      <D.24439>:
      <D.24436>:
      <D.24430>:
      D.24444 = BIT_FIELD_REF <*class, 8, 176>;
      D.24445 = (signed char) D.24444;
      D.24446 = D.24445 < 0;
      vt->remote = D.24446;
      D.24447 = domain->class_vtable_array;
      monoeg_g_ptr_array_add (D.24447, vt);
      mono_memory_barrier ();
      old_info = class->runtime_info;
      if (old_info != 0B) goto <D.24450>; else goto <D.24448>;
      <D.24450>:
      D.24451 = old_info->max_domain;
      D.24452 = (int) D.24451;
      D.24131 = domain->domain_id;
      if (D.24452 >= D.24131) goto <D.24453>; else goto <D.24448>;
      <D.24453>:
      D.24131 = domain->domain_id;
      old_info->domain_vtables[D.24131] = vt;
      goto <D.24449>;
      <D.24448>:
      {
        int new_size;

        new_size = domain->domain_id;
        if (old_info != 0B) goto <D.24454>; else goto <D.24455>;
        <D.24454>:
        D.24451 = old_info->max_domain;
        D.24456 = (int) D.24451;
        new_size = MAX_EXPR <D.24456, new_size>;
        <D.24455>:
        new_size = new_size + 1;
        i = 2;
        goto <D.21749>;
        <D.21748>:
        i = i << 1;
        <D.21749>:
        if (new_size > i) goto <D.21748>; else goto <D.21750>;
        <D.21750>:
        new_size = i;
        D.24457 = class->image;
        new_size.88 = (unsigned int) new_size;
        D.24459 = new_size.88 + 1;
        D.24460 = D.24459 * 4;
        runtime_info = mono_image_alloc0 (D.24457, D.24460);
        D.24461 = (short unsigned int) new_size;
        D.24462 = D.24461 + 65535;
        runtime_info->max_domain = D.24462;
        if (old_info != 0B) goto <D.24463>; else goto <D.24464>;
        <D.24463>:
        D.24465 = &runtime_info->domain_vtables;
        D.24466 = &old_info->domain_vtables;
        D.24451 = old_info->max_domain;
        D.24456 = (int) D.24451;
        D.24467 = D.24456 + 1;
        D.24468 = (unsigned int) D.24467;
        D.24469 = D.24468 * 4;
        memcpy (D.24465, D.24466, D.24469);
        <D.24464>:
        D.24131 = domain->domain_id;
        runtime_info->domain_vtables[D.24131] = vt;
        mono_memory_barrier ();
        class->runtime_info = runtime_info;
      }
      <D.24449>:
      D.24428 = mono_defaults.monotype_class;
      if (D.24428 == class) goto <D.24470>; else goto <D.24471>;
      <D.24470>:
      D.24431 = &class->byval_arg;
      D.24472 = mono_type_get_object (domain, D.24431);
      vt->type = D.24472;
      D.24433 = vt->type;
      D.24473 = mono_object_get_class (D.24433);
      D.24428 = mono_defaults.monotype_class;
      if (D.24473 != D.24428) goto <D.24474>; else goto <D.24475>;
      <D.24474>:
      D.24476 = mono_gc_is_moving ();
      if (D.24476 != 0) goto <D.24477>; else goto <D.24478>;
      <D.24477>:
      if (0 != 0) goto <D.24479>; else goto <D.24480>;
      <D.24479>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 2168, "sizeof (vt->type) == sizeof (MonoObject*)");
      <D.24480>:
      D.24442 = &vt->type;
      D.24481 = mono_gc_make_root_descr_all_refs (1);
      mono_gc_register_root (D.24442, 4, D.24481);
      <D.24478>:
      <D.24475>:
      <D.24471>:
      {
        int ret;

        D.24119 = &domain->lock.mutex;
        ret = pthread_mutex_unlock (D.24119);
        if (ret != 0) goto <D.24482>; else goto <D.24483>;
        <D.24482>:
        monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
        <D.24483>:
        D.24484 = ret != 0;
        D.24485 = (long int) D.24484;
        D.24486 = __builtin_expect (D.24485, 0);
        if (D.24486 != 0) goto <D.24487>; else goto <D.24488>;
        <D.24487>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 2171, "ret == 0");
        <D.24488>:
      }
      mono_loader_unlock ();
      D.24489 = mono_is_security_manager_active ();
      if (D.24489 != 0) goto <D.24490>; else goto <D.24491>;
      <D.24490>:
      D.24150 = class->exception_type;
      if (D.24150 == 2) goto <D.24492>; else goto <D.24493>;
      <D.24492>:
      if (raise_on_error != 0) goto <D.24494>; else goto <D.24495>;
      <D.24494>:
      D.24496 = mono_class_get_exception_for_failure (class);
      mono_raise_exception (D.24496);
      <D.24495>:
      <D.24493>:
      <D.24491>:
      D.24497 = class->parent;
      if (D.24497 != 0B) goto <D.24498>; else goto <D.24499>;
      <D.24498>:
      D.24497 = class->parent;
      mono_class_vtable_full (domain, D.24497, raise_on_error);
      <D.24499>:
      D.24144 = vt;
      return D.24144;
    }
  finally
    {
      iter = {CLOBBER};
    }
}


field_is_special_static (struct MonoClass * fklass, struct MonoClassField * field)
{
  gint32 D.24505;
  struct MonoMethod * D.24506;
  struct MonoImage * D.24507;
  struct MonoImage * D.24508;
  int D.21405;
  int iftmp.89;
  int D.21404;
  const char[22] * D.24514;
  unsigned char D.24515;
  int D.24516;
  unsigned char D.24517;
  int D.24518;
  _Bool D.24519;
  _Bool D.24520;
  _Bool D.24521;
  const unsigned char * D.24524;
  unsigned char D.24525;
  int D.24526;
  const unsigned char * D.24527;
  unsigned char D.24528;
  int D.24529;
  _Bool D.24530;
  _Bool D.24531;
  const unsigned char * D.24534;
  unsigned char D.24535;
  int D.24536;
  const unsigned char * D.24537;
  unsigned char D.24538;
  int D.24539;
  _Bool D.24540;
  _Bool D.24541;
  const unsigned char * D.24544;
  unsigned char D.24545;
  int D.24546;
  const unsigned char * D.24547;
  unsigned char D.24548;
  int D.24549;
  const char * D.24551;
  int D.21414;
  int iftmp.90;
  int D.21413;
  const char[23] * D.24557;
  unsigned char D.24558;
  int D.24559;
  unsigned char D.24560;
  int D.24561;
  _Bool D.24562;
  _Bool D.24563;
  _Bool D.24564;
  const unsigned char * D.24567;
  unsigned char D.24568;
  int D.24569;
  const unsigned char * D.24570;
  unsigned char D.24571;
  int D.24572;
  _Bool D.24573;
  _Bool D.24574;
  const unsigned char * D.24577;
  unsigned char D.24578;
  int D.24579;
  const unsigned char * D.24580;
  unsigned char D.24581;
  int D.24582;
  _Bool D.24583;
  _Bool D.24584;
  const unsigned char * D.24587;
  unsigned char D.24588;
  int D.24589;
  const unsigned char * D.24590;
  unsigned char D.24591;
  int D.24592;
  int D.24596;
  struct MonoCustomAttrInfo * ainfo;
  int i;

  ainfo = mono_custom_attrs_from_field (fklass, field);
  if (ainfo == 0B) goto <D.24503>; else goto <D.24504>;
  <D.24503>:
  D.24505 = 0;
  return D.24505;
  <D.24504>:
  i = 0;
  goto <D.21416>;
  <D.21415>:
  {
    struct MonoClass * klass;

    D.24506 = ainfo->attrs[i].ctor;
    klass = D.24506->klass;
    D.24507 = klass->image;
    D.24508 = mono_defaults.corlib;
    if (D.24507 == D.24508) goto <D.24509>; else goto <D.24510>;
    <D.24509>:
    {
      size_t __s1_len;
      size_t __s2_len;

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

        __s2 = klass->name;
        D.24514 = "ThreadStaticAttribute";
        D.24515 = MEM[(const unsigned char *)D.24514];
        D.24516 = (int) D.24515;
        D.24517 = *__s2;
        D.24518 = (int) D.24517;
        __result = D.24516 - D.24518;
        {
          D.24519 = __s2_len != 0;
          D.24520 = __result == 0;
          D.24521 = D.24519 & D.24520;
          if (D.24521 != 0) goto <D.24522>; else goto <D.24523>;
          <D.24522>:
          D.24524 = &MEM[(void *)"ThreadStaticAttribute" + 1B];
          D.24525 = *D.24524;
          D.24526 = (int) D.24525;
          D.24527 = __s2 + 1;
          D.24528 = *D.24527;
          D.24529 = (int) D.24528;
          __result = D.24526 - D.24529;
          D.24530 = __s2_len > 1;
          D.24520 = __result == 0;
          D.24531 = D.24530 & D.24520;
          if (D.24531 != 0) goto <D.24532>; else goto <D.24533>;
          <D.24532>:
          D.24534 = &MEM[(void *)"ThreadStaticAttribute" + 2B];
          D.24535 = *D.24534;
          D.24536 = (int) D.24535;
          D.24537 = __s2 + 2;
          D.24538 = *D.24537;
          D.24539 = (int) D.24538;
          __result = D.24536 - D.24539;
          D.24540 = __s2_len > 2;
          D.24520 = __result == 0;
          D.24541 = D.24540 & D.24520;
          if (D.24541 != 0) goto <D.24542>; else goto <D.24543>;
          <D.24542>:
          D.24544 = &MEM[(void *)"ThreadStaticAttribute" + 3B];
          D.24545 = *D.24544;
          D.24546 = (int) D.24545;
          D.24547 = __s2 + 3;
          D.24548 = *D.24547;
          D.24549 = (int) D.24548;
          __result = D.24546 - D.24549;
          <D.24543>:
          <D.24533>:
          <D.24523>:
        }
        D.21404 = __result;
      }
      iftmp.89 = -D.21404;
      goto <D.24550>;
      <D.24513>:
      D.24551 = klass->name;
      iftmp.89 = __builtin_strcmp (D.24551, "ThreadStaticAttribute");
      <D.24550>:
      D.21405 = iftmp.89;
    }
    if (D.21405 == 0) goto <D.24552>; else goto <D.24553>;
    <D.24552>:
    mono_custom_attrs_free (ainfo);
    D.24505 = 1;
    return D.24505;
    <D.24553>:
    {
      size_t __s1_len;
      size_t __s2_len;

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

        __s2 = klass->name;
        D.24557 = "ContextStaticAttribute";
        D.24558 = MEM[(const unsigned char *)D.24557];
        D.24559 = (int) D.24558;
        D.24560 = *__s2;
        D.24561 = (int) D.24560;
        __result = D.24559 - D.24561;
        {
          D.24562 = __s2_len != 0;
          D.24563 = __result == 0;
          D.24564 = D.24562 & D.24563;
          if (D.24564 != 0) goto <D.24565>; else goto <D.24566>;
          <D.24565>:
          D.24567 = &MEM[(void *)"ContextStaticAttribute" + 1B];
          D.24568 = *D.24567;
          D.24569 = (int) D.24568;
          D.24570 = __s2 + 1;
          D.24571 = *D.24570;
          D.24572 = (int) D.24571;
          __result = D.24569 - D.24572;
          D.24573 = __s2_len > 1;
          D.24563 = __result == 0;
          D.24574 = D.24573 & D.24563;
          if (D.24574 != 0) goto <D.24575>; else goto <D.24576>;
          <D.24575>:
          D.24577 = &MEM[(void *)"ContextStaticAttribute" + 2B];
          D.24578 = *D.24577;
          D.24579 = (int) D.24578;
          D.24580 = __s2 + 2;
          D.24581 = *D.24580;
          D.24582 = (int) D.24581;
          __result = D.24579 - D.24582;
          D.24583 = __s2_len > 2;
          D.24563 = __result == 0;
          D.24584 = D.24583 & D.24563;
          if (D.24584 != 0) goto <D.24585>; else goto <D.24586>;
          <D.24585>:
          D.24587 = &MEM[(void *)"ContextStaticAttribute" + 3B];
          D.24588 = *D.24587;
          D.24589 = (int) D.24588;
          D.24590 = __s2 + 3;
          D.24591 = *D.24590;
          D.24592 = (int) D.24591;
          __result = D.24589 - D.24592;
          <D.24586>:
          <D.24576>:
          <D.24566>:
        }
        D.21413 = __result;
      }
      iftmp.90 = -D.21413;
      goto <D.24593>;
      <D.24556>:
      D.24551 = klass->name;
      iftmp.90 = __builtin_strcmp (D.24551, "ContextStaticAttribute");
      <D.24593>:
      D.21414 = iftmp.90;
    }
    if (D.21414 == 0) goto <D.24594>; else goto <D.24595>;
    <D.24594>:
    mono_custom_attrs_free (ainfo);
    D.24505 = 2;
    return D.24505;
    <D.24595>:
    <D.24510>:
  }
  i = i + 1;
  <D.21416>:
  D.24596 = ainfo->num_attrs;
  if (D.24596 > i) goto <D.21415>; else goto <D.21417>;
  <D.21417>:
  mono_custom_attrs_free (ainfo);
  D.24505 = 0;
  return D.24505;
}


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.24598;
  long int D.24599;
  long int D.24600;
  short unsigned int D.24605;
  int D.24606;
  int D.24607;
  struct MonoVTable * D.24610;
  struct MonoVTable * D.24613;
  struct MonoClassRuntimeInfo * runtime_info;

  D.24598 = class == 0B;
  D.24599 = (long int) D.24598;
  D.24600 = __builtin_expect (D.24599, 0);
  if (D.24600 != 0) goto <D.24601>; else goto <D.24602>;
  <D.24601>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 1832, "class");
  <D.24602>:
  runtime_info = class->runtime_info;
  if (runtime_info != 0B) goto <D.24603>; else goto <D.24604>;
  <D.24603>:
  D.24605 = runtime_info->max_domain;
  D.24606 = (int) D.24605;
  D.24607 = domain->domain_id;
  if (D.24606 >= D.24607) goto <D.24608>; else goto <D.24609>;
  <D.24608>:
  D.24607 = domain->domain_id;
  D.24610 = runtime_info->domain_vtables[D.24607];
  if (D.24610 != 0B) goto <D.24611>; else goto <D.24612>;
  <D.24611>:
  D.24607 = domain->domain_id;
  D.24613 = runtime_info->domain_vtables[D.24607];
  return D.24613;
  <D.24612>:
  <D.24609>:
  <D.24604>:
  D.24613 = 0B;
  return D.24613;
}


mono_class_field_is_special_static (struct MonoClassField * field)
{
  struct MonoType * D.24615;
  short unsigned int D.24616;
  int D.24617;
  int D.24618;
  gboolean D.24621;
  int D.24622;
  int D.21826;
  int iftmp.91;
  int D.21825;
  const char[9] * D.24628;
  unsigned char D.24629;
  int D.24630;
  unsigned char D.24631;
  int D.24632;
  _Bool D.24633;
  _Bool D.24634;
  _Bool D.24635;
  const unsigned char * D.24638;
  unsigned char D.24639;
  int D.24640;
  const unsigned char * D.24641;
  unsigned char D.24642;
  int D.24643;
  _Bool D.24644;
  _Bool D.24645;
  const unsigned char * D.24648;
  unsigned char D.24649;
  int D.24650;
  const unsigned char * D.24651;
  unsigned char D.24652;
  int D.24653;
  _Bool D.24654;
  _Bool D.24655;
  const unsigned char * D.24658;
  unsigned char D.24659;
  int D.24660;
  const unsigned char * D.24661;
  unsigned char D.24662;
  int D.24663;
  const char * D.24665;
  int D.24668;
  struct MonoClass * D.24671;
  int D.24672;

  D.24615 = field->type;
  D.24616 = D.24615->attrs;
  D.24617 = (int) D.24616;
  D.24618 = D.24617 & 16;
  if (D.24618 == 0) goto <D.24619>; else goto <D.24620>;
  <D.24619>:
  D.24621 = 0;
  return D.24621;
  <D.24620>:
  D.24615 = field->type;
  D.24616 = D.24615->attrs;
  D.24617 = (int) D.24616;
  D.24622 = D.24617 & 1536;
  if (D.24622 != 0) goto <D.24623>; else goto <D.24624>;
  <D.24623>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = mono_field_get_name (field);
      D.24628 = "_Deleted";
      D.24629 = MEM[(const unsigned char *)D.24628];
      D.24630 = (int) D.24629;
      D.24631 = *__s2;
      D.24632 = (int) D.24631;
      __result = D.24630 - D.24632;
      {
        D.24633 = __s2_len != 0;
        D.24634 = __result == 0;
        D.24635 = D.24633 & D.24634;
        if (D.24635 != 0) goto <D.24636>; else goto <D.24637>;
        <D.24636>:
        D.24638 = &MEM[(void *)"_Deleted" + 1B];
        D.24639 = *D.24638;
        D.24640 = (int) D.24639;
        D.24641 = __s2 + 1;
        D.24642 = *D.24641;
        D.24643 = (int) D.24642;
        __result = D.24640 - D.24643;
        D.24644 = __s2_len > 1;
        D.24634 = __result == 0;
        D.24645 = D.24644 & D.24634;
        if (D.24645 != 0) goto <D.24646>; else goto <D.24647>;
        <D.24646>:
        D.24648 = &MEM[(void *)"_Deleted" + 2B];
        D.24649 = *D.24648;
        D.24650 = (int) D.24649;
        D.24651 = __s2 + 2;
        D.24652 = *D.24651;
        D.24653 = (int) D.24652;
        __result = D.24650 - D.24653;
        D.24654 = __s2_len > 2;
        D.24634 = __result == 0;
        D.24655 = D.24654 & D.24634;
        if (D.24655 != 0) goto <D.24656>; else goto <D.24657>;
        <D.24656>:
        D.24658 = &MEM[(void *)"_Deleted" + 3B];
        D.24659 = *D.24658;
        D.24660 = (int) D.24659;
        D.24661 = __s2 + 3;
        D.24662 = *D.24661;
        D.24663 = (int) D.24662;
        __result = D.24660 - D.24663;
        <D.24657>:
        <D.24647>:
        <D.24637>:
      }
      D.21825 = __result;
    }
    iftmp.91 = -D.21825;
    goto <D.24664>;
    <D.24627>:
    D.24665 = mono_field_get_name (field);
    iftmp.91 = __builtin_strcmp (D.24665, "_Deleted");
    <D.24664>:
    D.21826 = iftmp.91;
  }
  if (D.21826 == 0) goto <D.24666>; else goto <D.24667>;
  <D.24666>:
  D.24621 = 0;
  return D.24621;
  <D.24667>:
  <D.24624>:
  D.24615 = field->type;
  D.24616 = D.24615->attrs;
  D.24617 = (int) D.24616;
  D.24668 = D.24617 & 64;
  if (D.24668 == 0) goto <D.24669>; else goto <D.24670>;
  <D.24669>:
  D.24671 = field->parent;
  D.24672 = field_is_special_static (D.24671, field);
  if (D.24672 != 0) goto <D.24673>; else goto <D.24674>;
  <D.24673>:
  D.24621 = 1;
  return D.24621;
  <D.24674>:
  <D.24670>:
  D.24621 = 0;
  return D.24621;
}


mono_class_field_get_special_static_type (struct MonoClassField * field)
{
  struct MonoType * D.24676;
  short unsigned int D.24677;
  int D.24678;
  int D.24679;
  guint32 D.24682;
  int D.24683;
  int D.21838;
  int iftmp.92;
  int D.21837;
  const char[9] * D.24689;
  unsigned char D.24690;
  int D.24691;
  unsigned char D.24692;
  int D.24693;
  _Bool D.24694;
  _Bool D.24695;
  _Bool D.24696;
  const unsigned char * D.24699;
  unsigned char D.24700;
  int D.24701;
  const unsigned char * D.24702;
  unsigned char D.24703;
  int D.24704;
  _Bool D.24705;
  _Bool D.24706;
  const unsigned char * D.24709;
  unsigned char D.24710;
  int D.24711;
  const unsigned char * D.24712;
  unsigned char D.24713;
  int D.24714;
  _Bool D.24715;
  _Bool D.24716;
  const unsigned char * D.24719;
  unsigned char D.24720;
  int D.24721;
  const unsigned char * D.24722;
  unsigned char D.24723;
  int D.24724;
  const char * D.24726;
  int D.24729;
  struct MonoClass * D.24732;
  int D.24733;

  D.24676 = field->type;
  D.24677 = D.24676->attrs;
  D.24678 = (int) D.24677;
  D.24679 = D.24678 & 16;
  if (D.24679 == 0) goto <D.24680>; else goto <D.24681>;
  <D.24680>:
  D.24682 = 0;
  return D.24682;
  <D.24681>:
  D.24676 = field->type;
  D.24677 = D.24676->attrs;
  D.24678 = (int) D.24677;
  D.24683 = D.24678 & 1536;
  if (D.24683 != 0) goto <D.24684>; else goto <D.24685>;
  <D.24684>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = mono_field_get_name (field);
      D.24689 = "_Deleted";
      D.24690 = MEM[(const unsigned char *)D.24689];
      D.24691 = (int) D.24690;
      D.24692 = *__s2;
      D.24693 = (int) D.24692;
      __result = D.24691 - D.24693;
      {
        D.24694 = __s2_len != 0;
        D.24695 = __result == 0;
        D.24696 = D.24694 & D.24695;
        if (D.24696 != 0) goto <D.24697>; else goto <D.24698>;
        <D.24697>:
        D.24699 = &MEM[(void *)"_Deleted" + 1B];
        D.24700 = *D.24699;
        D.24701 = (int) D.24700;
        D.24702 = __s2 + 1;
        D.24703 = *D.24702;
        D.24704 = (int) D.24703;
        __result = D.24701 - D.24704;
        D.24705 = __s2_len > 1;
        D.24695 = __result == 0;
        D.24706 = D.24705 & D.24695;
        if (D.24706 != 0) goto <D.24707>; else goto <D.24708>;
        <D.24707>:
        D.24709 = &MEM[(void *)"_Deleted" + 2B];
        D.24710 = *D.24709;
        D.24711 = (int) D.24710;
        D.24712 = __s2 + 2;
        D.24713 = *D.24712;
        D.24714 = (int) D.24713;
        __result = D.24711 - D.24714;
        D.24715 = __s2_len > 2;
        D.24695 = __result == 0;
        D.24716 = D.24715 & D.24695;
        if (D.24716 != 0) goto <D.24717>; else goto <D.24718>;
        <D.24717>:
        D.24719 = &MEM[(void *)"_Deleted" + 3B];
        D.24720 = *D.24719;
        D.24721 = (int) D.24720;
        D.24722 = __s2 + 3;
        D.24723 = *D.24722;
        D.24724 = (int) D.24723;
        __result = D.24721 - D.24724;
        <D.24718>:
        <D.24708>:
        <D.24698>:
      }
      D.21837 = __result;
    }
    iftmp.92 = -D.21837;
    goto <D.24725>;
    <D.24688>:
    D.24726 = mono_field_get_name (field);
    iftmp.92 = __builtin_strcmp (D.24726, "_Deleted");
    <D.24725>:
    D.21838 = iftmp.92;
  }
  if (D.21838 == 0) goto <D.24727>; else goto <D.24728>;
  <D.24727>:
  D.24682 = 0;
  return D.24682;
  <D.24728>:
  <D.24685>:
  D.24676 = field->type;
  D.24677 = D.24676->attrs;
  D.24678 = (int) D.24677;
  D.24729 = D.24678 & 64;
  if (D.24729 == 0) goto <D.24730>; else goto <D.24731>;
  <D.24730>:
  D.24732 = field->parent;
  D.24733 = field_is_special_static (D.24732, field);
  D.24682 = (guint32) D.24733;
  return D.24682;
  <D.24731>:
  D.24682 = 0;
  return D.24682;
}


mono_class_has_special_static_fields (struct MonoClass * klass)
{
  struct MonoClass * D.24735;
  _Bool D.24736;
  long int D.24737;
  long int D.24738;
  int D.24741;
  gboolean D.24744;
  struct MonoClassField * field;
  void * iter;

  try
    {
      iter = 0B;
      goto <D.21845>;
      <D.21844>:
      D.24735 = field->parent;
      D.24736 = D.24735 != klass;
      D.24737 = (long int) D.24736;
      D.24738 = __builtin_expect (D.24737, 0);
      if (D.24738 != 0) goto <D.24739>; else goto <D.24740>;
      <D.24739>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 2420, "field->parent == klass");
      <D.24740>:
      D.24741 = mono_class_field_is_special_static (field);
      if (D.24741 != 0) goto <D.24742>; else goto <D.24743>;
      <D.24742>:
      D.24744 = 1;
      return D.24744;
      <D.24743>:
      <D.21845>:
      field = mono_class_get_fields (klass, &iter);
      if (field != 0B) goto <D.21844>; else goto <D.21846>;
      <D.21846>:
      D.24744 = 0;
      return D.24744;
    }
  finally
    {
      iter = {CLOBBER};
    }
}


mono_remote_class (struct MonoDomain * domain, struct MonoString * class_name, struct MonoClass * proxy_class)
{
  union mono_mutex_t * D.24747;
  _Bool D.24750;
  long int D.24751;
  long int D.24752;
  struct GHashTable * D.24755;
  _Bool D.24760;
  long int D.24761;
  long int D.24762;
  struct MonoRemoteClass * D.24765;
  struct MonoMemPool * D.24766;
  int D.24767;
  _Bool D.24772;
  long int D.24773;
  long int D.24774;
  unsigned int D.24777;
  unsigned int D.24778;
  struct MonoClass * D.24781;
  int D.24783;
  int D.24784;
  struct MonoPerfCounters * mono_perfcounters.93;
  unsigned int D.24786;
  unsigned int D.24787;
  unsigned int D.24788;
  _Bool D.24791;
  long int D.24792;
  long int D.24793;
  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.24747 = &domain->lock.mutex;
        ret = pthread_mutex_lock (D.24747);
        if (ret != 0) goto <D.24748>; else goto <D.24749>;
        <D.24748>:
        monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
        <D.24749>:
        D.24750 = ret != 0;
        D.24751 = (long int) D.24750;
        D.24752 = __builtin_expect (D.24751, 0);
        if (D.24752 != 0) goto <D.24753>; else goto <D.24754>;
        <D.24753>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 2515, "ret == 0");
        <D.24754>:
      }
      D.24755 = domain->proxy_vtable_hash;
      rc = monoeg_g_hash_table_lookup (D.24755, key);
      if (rc != 0B) goto <D.24756>; else goto <D.24757>;
      <D.24756>:
      monoeg_g_free (key);
      {
        int ret;

        D.24747 = &domain->lock.mutex;
        ret = pthread_mutex_unlock (D.24747);
        if (ret != 0) goto <D.24758>; else goto <D.24759>;
        <D.24758>:
        monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
        <D.24759>:
        D.24760 = ret != 0;
        D.24761 = (long int) D.24760;
        D.24762 = __builtin_expect (D.24761, 0);
        if (D.24762 != 0) goto <D.24763>; else goto <D.24764>;
        <D.24763>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 2520, "ret == 0");
        <D.24764>:
      }
      D.24765 = rc;
      return D.24765;
      <D.24757>:
      D.24766 = domain->mp;
      name = mono_string_to_utf8_mp (D.24766, class_name, &error);
      D.24767 = mono_error_ok (&error);
      if (D.24767 == 0) goto <D.24768>; else goto <D.24769>;
      <D.24768>:
      monoeg_g_free (key);
      {
        int ret;

        D.24747 = &domain->lock.mutex;
        ret = pthread_mutex_unlock (D.24747);
        if (ret != 0) goto <D.24770>; else goto <D.24771>;
        <D.24770>:
        monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
        <D.24771>:
        D.24772 = ret != 0;
        D.24773 = (long int) D.24772;
        D.24774 = __builtin_expect (D.24773, 0);
        if (D.24774 != 0) goto <D.24775>; else goto <D.24776>;
        <D.24775>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 2527, "ret == 0");
        <D.24776>:
      }
      mono_error_raise_exception (&error);
      <D.24769>:
      mp_key = copy_remote_class_key (domain, key);
      monoeg_g_free (key);
      key = mp_key;
      D.24777 = proxy_class->flags;
      D.24778 = D.24777 & 32;
      if (D.24778 != 0) goto <D.24779>; else goto <D.24780>;
      <D.24779>:
      rc = mono_domain_alloc (domain, 24);
      rc->interface_count = 1;
      rc->interfaces[0] = proxy_class;
      D.24781 = mono_defaults.marshalbyrefobject_class;
      rc->proxy_class = D.24781;
      goto <D.24782>;
      <D.24780>:
      rc = mono_domain_alloc (domain, 20);
      rc->interface_count = 0;
      rc->proxy_class = proxy_class;
      <D.24782>:
      rc->default_vtable = 0B;
      rc->xdomain_vtable = 0B;
      rc->proxy_class_name = name;
      D.24783 = mono_string_length (class_name);
      D.24784 = D.24783 + 1;
      mono_perfcounters.93 = mono_perfcounters;
      mono_perfcounters.93 = mono_perfcounters;
      D.24786 = mono_perfcounters.93->loader_bytes;
      D.24787 = (unsigned int) D.24784;
      D.24788 = D.24786 + D.24787;
      mono_perfcounters.93->loader_bytes = D.24788;
      D.24755 = domain->proxy_vtable_hash;
      monoeg_g_hash_table_insert_replace (D.24755, key, rc, 0);
      {
        int ret;

        D.24747 = &domain->lock.mutex;
        ret = pthread_mutex_unlock (D.24747);
        if (ret != 0) goto <D.24789>; else goto <D.24790>;
        <D.24789>:
        monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
        <D.24790>:
        D.24791 = ret != 0;
        D.24792 = (long int) D.24791;
        D.24793 = __builtin_expect (D.24792, 0);
        if (D.24793 != 0) goto <D.24794>; else goto <D.24795>;
        <D.24794>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 2555, "ret == 0");
        <D.24795>:
      }
      D.24765 = rc;
      return D.24765;
    }
  finally
    {
      error = {CLOBBER};
    }
}


create_remote_class_key (struct MonoRemoteClass * remote_class, struct MonoClass * extra_class)
{
  unsigned int D.24800;
  unsigned int D.24801;
  void * * D.24804;
  struct MonoClass * D.24805;
  void * * D.24806;
  unsigned int D.24812;
  unsigned int D.24813;
  unsigned int D.24814;
  unsigned int D.24815;
  void * D.24816;
  struct MonoClass * D.24817;
  struct MonoClass * D.24820;
  int j.94;
  unsigned int j.95;
  unsigned int D.24825;
  void * * D.24826;
  unsigned int j.96;
  unsigned int D.24828;
  void * * D.24829;
  unsigned int i.97;
  unsigned int D.24833;
  unsigned int D.24834;
  void * D.24835;
  struct MonoClass * iftmp.98;
  int D.24840;
  unsigned int D.24841;
  unsigned int D.24842;
  void * * D.24843;
  void * * D.24844;
  void * * key;
  int i;
  int j;

  if (remote_class == 0B) goto <D.24798>; else goto <D.24799>;
  <D.24798>:
  D.24800 = extra_class->flags;
  D.24801 = D.24800 & 32;
  if (D.24801 != 0) goto <D.24802>; else goto <D.24803>;
  <D.24802>:
  key = monoeg_malloc (12);
  *key = 2B;
  D.24804 = key + 4;
  D.24805 = mono_defaults.marshalbyrefobject_class;
  *D.24804 = D.24805;
  D.24806 = key + 8;
  *D.24806 = extra_class;
  goto <D.24807>;
  <D.24803>:
  key = monoeg_malloc (8);
  *key = 1B;
  D.24804 = key + 4;
  *D.24804 = extra_class;
  <D.24807>:
  goto <D.24808>;
  <D.24799>:
  if (extra_class != 0B) goto <D.24810>; else goto <D.24809>;
  <D.24810>:
  D.24800 = extra_class->flags;
  D.24801 = D.24800 & 32;
  if (D.24801 != 0) goto <D.24811>; else goto <D.24809>;
  <D.24811>:
  D.24812 = remote_class->interface_count;
  D.24813 = D.24812 + 3;
  D.24814 = D.24813 * 4;
  key = monoeg_malloc (D.24814);
  D.24812 = remote_class->interface_count;
  D.24815 = D.24812 + 2;
  D.24816 = (void *) D.24815;
  *key = D.24816;
  D.24804 = key + 4;
  D.24817 = remote_class->proxy_class;
  *D.24804 = D.24817;
  i = 0;
  j = 2;
  goto <D.21855>;
  <D.21854>:
  if (extra_class != 0B) goto <D.24818>; else goto <D.24819>;
  <D.24818>:
  D.24820 = remote_class->interfaces[i];
  if (D.24820 > extra_class) goto <D.24821>; else goto <D.24822>;
  <D.24821>:
  j.94 = j;
  j = j.94 + 1;
  j.95 = (unsigned int) j.94;
  D.24825 = j.95 * 4;
  D.24826 = key + D.24825;
  *D.24826 = extra_class;
  extra_class = 0B;
  <D.24822>:
  <D.24819>:
  j.96 = (unsigned int) j;
  D.24828 = j.96 * 4;
  D.24829 = key + D.24828;
  D.24820 = remote_class->interfaces[i];
  *D.24829 = D.24820;
  i = i + 1;
  j = j + 1;
  <D.21855>:
  i.97 = (unsigned int) i;
  D.24812 = remote_class->interface_count;
  if (i.97 < D.24812) goto <D.21854>; else goto <D.21856>;
  <D.21856>:
  if (extra_class != 0B) goto <D.24831>; else goto <D.24832>;
  <D.24831>:
  j.96 = (unsigned int) j;
  D.24828 = j.96 * 4;
  D.24829 = key + D.24828;
  *D.24829 = extra_class;
  <D.24832>:
  goto <D.21859>;
  <D.24809>:
  D.24812 = remote_class->interface_count;
  D.24815 = D.24812 + 2;
  D.24833 = D.24815 * 4;
  key = monoeg_malloc (D.24833);
  D.24812 = remote_class->interface_count;
  D.24834 = D.24812 + 1;
  D.24835 = (void *) D.24834;
  *key = D.24835;
  D.24804 = key + 4;
  if (extra_class == 0B) goto <D.24837>; else goto <D.24838>;
  <D.24837>:
  iftmp.98 = remote_class->proxy_class;
  goto <D.24839>;
  <D.24838>:
  iftmp.98 = extra_class;
  <D.24839>:
  *D.24804 = iftmp.98;
  i = 0;
  goto <D.21858>;
  <D.21857>:
  D.24840 = i + 2;
  D.24841 = (unsigned int) D.24840;
  D.24842 = D.24841 * 4;
  D.24843 = key + D.24842;
  D.24820 = remote_class->interfaces[i];
  *D.24843 = D.24820;
  i = i + 1;
  <D.21858>:
  i.97 = (unsigned int) i;
  D.24812 = remote_class->interface_count;
  if (i.97 < D.24812) goto <D.21857>; else goto <D.21859>;
  <D.21859>:
  <D.24808>:
  D.24844 = key;
  return D.24844;
}


copy_remote_class_key (struct MonoDomain * domain, void * * key)
{
  void * D.24846;
  unsigned int D.24847;
  unsigned int D.24848;
  unsigned int D.24849;
  unsigned int key_size.99;
  unsigned int key_size.100;
  void * * D.24852;
  int key_size;
  void * * mp_key;

  D.24846 = *key;
  D.24847 = (unsigned int) D.24846;
  D.24848 = D.24847 + 1;
  D.24849 = D.24848 * 4;
  key_size = (int) D.24849;
  key_size.99 = (unsigned int) key_size;
  mp_key = mono_domain_alloc (domain, key_size.99);
  key_size.100 = (unsigned int) key_size;
  memcpy (mp_key, key, key_size.100);
  D.24852 = mp_key;
  return D.24852;
}


mono_remote_class_vtable (struct MonoDomain * domain, struct MonoRemoteClass * remote_class, struct MonoRealProxy * rp)
{
  union mono_mutex_t * D.24854;
  _Bool D.24857;
  long int D.24858;
  long int D.24859;
  int D.24862;
  struct MonoVTable * D.24865;
  struct MonoVTable * D.24868;
  _Bool D.24871;
  long int D.24872;
  long int D.24873;
  void * D.24876;
  struct MonoVTable * D.24877;
  struct MonoReflectionType * D.24880;
  unsigned char D.24884;
  unsigned char D.24885;
  struct MonoClass * D.24887;
  struct MonoClass * D.24889;
  struct MonoDomain * D.24890;
  struct MonoVTable * D.24891;
  unsigned char D.24892;
  unsigned char D.24893;
  struct MonoVTable * D.24895;
  struct MonoVTable * D.24896;
  _Bool D.24899;
  long int D.24900;
  long int D.24901;

  mono_loader_lock ();
  {
    int ret;

    D.24854 = &domain->lock.mutex;
    ret = pthread_mutex_lock (D.24854);
    if (ret != 0) goto <D.24855>; else goto <D.24856>;
    <D.24855>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
    <D.24856>:
    D.24857 = ret != 0;
    D.24858 = (long int) D.24857;
    D.24859 = __builtin_expect (D.24858, 0);
    if (D.24859 != 0) goto <D.24860>; else goto <D.24861>;
    <D.24860>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 2617, "ret == 0");
    <D.24861>:
  }
  D.24862 = rp->target_domain_id;
  if (D.24862 != -1) goto <D.24863>; else goto <D.24864>;
  <D.24863>:
  D.24865 = remote_class->xdomain_vtable;
  if (D.24865 == 0B) goto <D.24866>; else goto <D.24867>;
  <D.24866>:
  D.24868 = mono_class_proxy_vtable (domain, remote_class, 1);
  remote_class->xdomain_vtable = D.24868;
  <D.24867>:
  {
    int ret;

    D.24854 = &domain->lock.mutex;
    ret = pthread_mutex_unlock (D.24854);
    if (ret != 0) goto <D.24869>; else goto <D.24870>;
    <D.24869>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.24870>:
    D.24871 = ret != 0;
    D.24872 = (long int) D.24871;
    D.24873 = __builtin_expect (D.24872, 0);
    if (D.24873 != 0) goto <D.24874>; else goto <D.24875>;
    <D.24874>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 2621, "ret == 0");
    <D.24875>:
  }
  mono_loader_unlock ();
  D.24876 = remote_class->xdomain_vtable;
  return D.24876;
  <D.24864>:
  D.24877 = remote_class->default_vtable;
  if (D.24877 == 0B) goto <D.24878>; else goto <D.24879>;
  <D.24878>:
  {
    struct MonoType * type;
    struct MonoClass * klass;

    D.24880 = rp->class_to_proxy;
    type = D.24880->type;
    klass = mono_class_from_mono_type (type);
    D.24884 = BIT_FIELD_REF <*klass, 8, 184>;
    D.24885 = D.24884 & 64;
    if (D.24885 != 0) goto <D.24881>; else goto <D.24886>;
    <D.24886>:
    D.24887 = mono_class_get_com_object_class ();
    if (D.24887 != 0B) goto <D.24888>; else goto <D.24882>;
    <D.24888>:
    D.24889 = mono_class_get_com_object_class ();
    if (D.24889 == klass) goto <D.24881>; else goto <D.24882>;
    <D.24881>:
    D.24890 = mono_domain_get ();
    D.24891 = mono_class_vtable (D.24890, klass);
    D.24892 = BIT_FIELD_REF <*D.24891, 8, 184>;
    D.24893 = D.24892 & 1;
    if (D.24893 == 0) goto <D.24894>; else goto <D.24882>;
    <D.24894>:
    D.24895 = mono_class_proxy_vtable (domain, remote_class, 2);
    remote_class->default_vtable = D.24895;
    goto <D.24883>;
    <D.24882>:
    D.24896 = mono_class_proxy_vtable (domain, remote_class, 0);
    remote_class->default_vtable = D.24896;
    <D.24883>:
  }
  <D.24879>:
  {
    int ret;

    D.24854 = &domain->lock.mutex;
    ret = pthread_mutex_unlock (D.24854);
    if (ret != 0) goto <D.24897>; else goto <D.24898>;
    <D.24897>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.24898>:
    D.24899 = ret != 0;
    D.24900 = (long int) D.24899;
    D.24901 = __builtin_expect (D.24900, 0);
    if (D.24901 != 0) goto <D.24902>; else goto <D.24903>;
    <D.24902>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 2638, "ret == 0");
    <D.24903>:
  }
  mono_loader_unlock ();
  D.24876 = remote_class->default_vtable;
  return D.24876;
}


mono_class_proxy_vtable (struct MonoDomain * domain, struct MonoRemoteClass * remote_class, MonoRemotingTarget target_type)
{
  _Bool D.24905;
  long int D.24906;
  long int D.24907;
  short unsigned int D.24910;
  short unsigned int D.24911;
  short unsigned int D.24912;
  guint8 * D.24915;
  short unsigned int D.24916;
  sizetype D.24917;
  guint8 * D.24918;
  unsigned char D.24919;
  int D.24920;
  int D.24921;
  int D.24922;
  int D.24923;
  int D.24924;
  struct GSList * D.24927;
  int D.24930;
  _Bool D.24931;
  long int D.24932;
  long int D.24933;
  void * * D.24938;
  unsigned int i.101;
  unsigned int D.24940;
  void * * D.24941;
  short unsigned int D.24942;
  short unsigned int D.24945;
  sizetype D.24946;
  guint8 * D.24947;
  unsigned char D.24948;
  int D.24949;
  int D.24950;
  int D.24951;
  int D.24952;
  int D.24953;
  struct GSList * D.24956;
  int D.24959;
  unsigned int i.102;
  unsigned int D.24961;
  unsigned int method_count.103;
  unsigned int D.24963;
  unsigned int extra_interface_vtsize.104;
  unsigned int D.24965;
  short unsigned int D.24966;
  int D.24967;
  unsigned int j.105;
  unsigned int D.24971;
  void * (*<T314f>) (struct MonoVTable *, struct MonoDomain *, struct MonoIMTCheckItem * *, int, void *) imt_thunk_builder.106;
  long unsigned int D.24975;
  long unsigned int D.24976;
  long unsigned int D.24977;
  long unsigned int D.24978;
  int D.24979;
  unsigned int D.24980;
  unsigned int D.24981;
  unsigned int D.24982;
  unsigned int max_interface_id.107;
  unsigned int D.24985;
  unsigned int D.24986;
  unsigned int D.24987;
  long unsigned int D.24988;
  int D.24989;
  long unsigned int D.24990;
  long unsigned int D.24991;
  unsigned int D.24992;
  sizetype max_interface_id.108;
  sizetype D.24997;
  sizetype D.24998;
  unsigned int D.24999;
  unsigned int D.25000;
  struct MonoClass * D.25001;
  void * D.25002;
  struct MonoMethod * * D.25003;
  struct MonoMethod * * D.25004;
  void * (*<T279f>) (struct MonoDomain *, struct MonoMethod *, MonoRemotingTarget) arch_create_remoting_trampoline.109;
  void * D.25008;
  unsigned int D.25010;
  unsigned int D.25011;
  short int D.25014;
  int D.25015;
  void * D.25016;
  void * D.25019;
  short unsigned int D.25020;
  int D.25021;
  unsigned int bsize.110;
  struct MonoClass * * D.25025;
  struct MonoClass * * D.25026;
  struct MonoClass * D.25027;
  short unsigned int D.25028;
  guint16 * D.25029;
  unsigned int D.25030;
  guint16 * D.25031;
  short unsigned int D.25032;
  int D.25033;
  int D.25034;
  unsigned int D.25035;
  unsigned int D.25036;
  void * * D.25037;
  void * * D.25038;
  short unsigned int D.25039;
  int D.25040;
  int D.25041;
  sizetype D.25042;
  uint8_t * D.25043;
  unsigned char D.25044;
  signed char D.25045;
  int D.25046;
  int D.25047;
  signed char D.25048;
  signed char D.25049;
  unsigned char D.25050;
  short unsigned int D.25055;
  int D.25056;
  int D.25057;
  unsigned int D.25058;
  unsigned int D.25059;
  void * * D.25060;
  void * * D.25061;
  short unsigned int D.25062;
  sizetype D.25063;
  uint8_t * D.25064;
  unsigned char D.25065;
  signed char D.25066;
  int D.25067;
  int D.25068;
  signed char D.25069;
  signed char D.25070;
  unsigned char D.25071;
  int j.111;
  int D.25073;
  void * D.25074;
  int D.25075;
  struct MonoVTable * D.25082;
  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.24905 = vt == 0B;
      D.24906 = (long int) D.24905;
      D.24907 = __builtin_expect (D.24906, 0);
      if (D.24907 != 0) goto <D.24908>; else goto <D.24909>;
      <D.24908>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 2215, "vt");
      <D.24909>:
      D.24910 = vt->max_interface_id;
      max_interface_id = (int) D.24910;
      j = 0;
      goto <D.21781>;
      <D.21780>:
      {
        struct MonoClass * iclass;
        struct GPtrArray * ifaces;
        int method_count;

        iclass = remote_class->interfaces[j];
        D.24911 = iclass->interface_id;
        D.24912 = class->max_interface_id;
        if (D.24911 <= D.24912) goto <D.24913>; else goto <D.24914>;
        <D.24913>:
        D.24915 = class->interface_bitmap;
        D.24911 = iclass->interface_id;
        D.24916 = D.24911 >> 3;
        D.24917 = (sizetype) D.24916;
        D.24918 = D.24915 + D.24917;
        D.24919 = *D.24918;
        D.24920 = (int) D.24919;
        D.24911 = iclass->interface_id;
        D.24921 = (int) D.24911;
        D.24922 = D.24921 & 7;
        D.24923 = D.24920 >> D.24922;
        D.24924 = D.24923 & 1;
        if (D.24924 != 0) goto <D.24925>; else goto <D.24926>;
        <D.24925>:
        // predicted unlikely by continue predictor.
        goto <D.21774>;
        <D.24926>:
        <D.24914>:
        D.24927 = monoeg_g_slist_find (extra_interfaces, iclass);
        if (D.24927 != 0B) goto <D.24928>; else goto <D.24929>;
        <D.24928>:
        // predicted unlikely by continue predictor.
        goto <D.21774>;
        <D.24929>:
        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.24930 = mono_error_ok (&error);
        D.24931 = D.24930 == 0;
        D.24932 = (long int) D.24931;
        D.24933 = __builtin_expect (D.24932, 0);
        if (D.24933 != 0) goto <D.24934>; else goto <D.24935>;
        <D.24934>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 2235, "mono_error_ok (&error)");
        <D.24935>:
        if (ifaces != 0B) goto <D.24936>; else goto <D.24937>;
        <D.24936>:
        i = 0;
        goto <D.21778>;
        <D.21777>:
        {
          struct MonoClass * ic;

          D.24938 = ifaces->pdata;
          i.101 = (unsigned int) i;
          D.24940 = i.101 * 4;
          D.24941 = D.24938 + D.24940;
          ic = *D.24941;
          D.24942 = ic->interface_id;
          D.24912 = class->max_interface_id;
          if (D.24942 <= D.24912) goto <D.24943>; else goto <D.24944>;
          <D.24943>:
          D.24915 = class->interface_bitmap;
          D.24942 = ic->interface_id;
          D.24945 = D.24942 >> 3;
          D.24946 = (sizetype) D.24945;
          D.24947 = D.24915 + D.24946;
          D.24948 = *D.24947;
          D.24949 = (int) D.24948;
          D.24942 = ic->interface_id;
          D.24950 = (int) D.24942;
          D.24951 = D.24950 & 7;
          D.24952 = D.24949 >> D.24951;
          D.24953 = D.24952 & 1;
          if (D.24953 != 0) goto <D.24954>; else goto <D.24955>;
          <D.24954>:
          // predicted unlikely by continue predictor.
          goto <D.21776>;
          <D.24955>:
          <D.24944>:
          D.24956 = monoeg_g_slist_find (extra_interfaces, ic);
          if (D.24956 != 0B) goto <D.24957>; else goto <D.24958>;
          <D.24957>:
          // predicted unlikely by continue predictor.
          goto <D.21776>;
          <D.24958>:
          extra_interfaces = monoeg_g_slist_prepend (extra_interfaces, ic);
          D.24959 = mono_class_num_methods (ic);
          method_count = D.24959 + method_count;
        }
        <D.21776>:
        i = i + 1;
        <D.21778>:
        i.102 = (unsigned int) i;
        D.24961 = ifaces->len;
        if (i.102 < D.24961) goto <D.21777>; else goto <D.21779>;
        <D.21779>:
        monoeg_g_ptr_array_free (ifaces, 1);
        <D.24937>:
        method_count.103 = (unsigned int) method_count;
        D.24963 = method_count.103 * 4;
        extra_interface_vtsize.104 = (unsigned int) extra_interface_vtsize;
        D.24965 = D.24963 + extra_interface_vtsize.104;
        extra_interface_vtsize = (int) D.24965;
        D.24966 = iclass->max_interface_id;
        D.24967 = (int) D.24966;
        if (D.24967 > max_interface_id) goto <D.24968>; else goto <D.24969>;
        <D.24968>:
        D.24966 = iclass->max_interface_id;
        max_interface_id = (int) D.24966;
        <D.24969>:
      }
      <D.21774>:
      j = j + 1;
      <D.21781>:
      j.105 = (unsigned int) j;
      D.24971 = remote_class->interface_count;
      if (j.105 < D.24971) goto <D.21780>; else goto <D.21782>;
      <D.21782>:
      imt_thunk_builder.106 = imt_thunk_builder;
      if (imt_thunk_builder.106 != 0B) goto <D.24973>; else goto <D.24974>;
      <D.24973>:
      D.24975 = mono_stats.imt_number_of_tables;
      D.24976 = D.24975 + 1;
      mono_stats.imt_number_of_tables = D.24976;
      D.24977 = mono_stats.imt_tables_size;
      D.24978 = D.24977 + 76;
      mono_stats.imt_tables_size = D.24978;
      D.24979 = class->vtable_size;
      D.24980 = (unsigned int) D.24979;
      D.24981 = D.24980 + 27;
      D.24982 = D.24981 * 4;
      vtsize = (int) D.24982;
      goto <D.24983>;
      <D.24974>:
      D.24979 = class->vtable_size;
      D.24980 = (unsigned int) D.24979;
      max_interface_id.107 = (unsigned int) max_interface_id;
      D.24985 = D.24980 + max_interface_id.107;
      D.24986 = D.24985 + 9;
      D.24987 = D.24986 * 4;
      vtsize = (int) D.24987;
      <D.24983>:
      D.24988 = mono_stats.class_vtable_size;
      D.24989 = vtsize + extra_interface_vtsize;
      D.24990 = (long unsigned int) D.24989;
      D.24991 = D.24988 + D.24990;
      mono_stats.class_vtable_size = D.24991;
      D.24989 = vtsize + extra_interface_vtsize;
      D.24992 = (unsigned int) D.24989;
      interface_offsets = mono_domain_alloc0 (domain, D.24992);
      imt_thunk_builder.106 = imt_thunk_builder;
      if (imt_thunk_builder.106 != 0B) goto <D.24993>; else goto <D.24994>;
      <D.24993>:
      pvt = interface_offsets + 76;
      goto <D.24995>;
      <D.24994>:
      max_interface_id.108 = (sizetype) max_interface_id;
      D.24997 = max_interface_id.108 + 1;
      D.24998 = D.24997 * 4;
      pvt = interface_offsets + D.24998;
      <D.24995>:
      D.24979 = class->vtable_size;
      D.24980 = (unsigned int) D.24979;
      D.24999 = D.24980 + 8;
      D.25000 = D.24999 * 4;
      memcpy (pvt, vt, D.25000);
      D.25001 = mono_defaults.transparent_proxy_class;
      pvt->klass = D.25001;
      D.25001 = mono_defaults.transparent_proxy_class;
      D.25002 = D.25001->gc_descr;
      pvt->gc_descr = D.25002;
      mono_class_setup_vtable (class);
      i = 0;
      goto <D.21785>;
      <D.21784>:
      {
        struct MonoMethod * cm;

        D.25003 = class->vtable;
        i.101 = (unsigned int) i;
        D.24940 = i.101 * 4;
        D.25004 = D.25003 + D.24940;
        cm = *D.25004;
        if (cm != 0B) goto <D.25005>; else goto <D.25006>;
        <D.25005>:
        arch_create_remoting_trampoline.109 = arch_create_remoting_trampoline;
        D.25008 = arch_create_remoting_trampoline.109 (domain, cm, target_type);
        pvt->vtable[i] = D.25008;
        goto <D.25009>;
        <D.25006>:
        pvt->vtable[i] = 0B;
        <D.25009>:
      }
      i = i + 1;
      <D.21785>:
      D.24979 = class->vtable_size;
      if (D.24979 > i) goto <D.21784>; else goto <D.21786>;
      <D.21786>:
      D.25010 = class->flags;
      D.25011 = D.25010 & 128;
      if (D.25011 != 0) goto <D.25012>; else goto <D.25013>;
      <D.25012>:
      k = class;
      goto <D.21793>;
      <D.21792>:
      {
        struct MonoMethod * m;
        void * iter;

        try
          {
            iter = 0B;
            goto <D.21790>;
            <D.21789>:
            D.25014 = m->slot;
            D.25015 = (int) D.25014;
            D.25016 = pvt->vtable[D.25015];
            if (D.25016 == 0B) goto <D.25017>; else goto <D.25018>;
            <D.25017>:
            D.25014 = m->slot;
            D.25015 = (int) D.25014;
            arch_create_remoting_trampoline.109 = arch_create_remoting_trampoline;
            D.25019 = arch_create_remoting_trampoline.109 (domain, m, target_type);
            pvt->vtable[D.25015] = D.25019;
            <D.25018>:
            <D.21790>:
            m = mono_class_get_methods (k, &iter);
            if (m != 0B) goto <D.21789>; else goto <D.21791>;
            <D.21791>:
          }
        finally
          {
            iter = {CLOBBER};
          }
      }
      k = k->parent;
      <D.21793>:
      if (k != 0B) goto <D.21792>; else goto <D.21794>;
      <D.21794>:
      <D.25013>:
      D.25020 = (short unsigned int) max_interface_id;
      pvt->max_interface_id = D.25020;
      D.25021 = max_interface_id / 8;
      bsize = D.25021 + 1;
      bsize.110 = (unsigned int) bsize;
      bitmap = mono_domain_alloc0 (domain, bsize.110);
      imt_thunk_builder.106 = imt_thunk_builder;
      if (imt_thunk_builder.106 == 0B) goto <D.25023>; else goto <D.25024>;
      <D.25023>:
      i = 0;
      goto <D.21798>;
      <D.21797>:
      {
        int interface_id;
        int slot;

        D.25025 = class->interfaces_packed;
        i.101 = (unsigned int) i;
        D.24940 = i.101 * 4;
        D.25026 = D.25025 + D.24940;
        D.25027 = *D.25026;
        D.25028 = D.25027->interface_id;
        interface_id = (int) D.25028;
        D.25029 = class->interface_offsets_packed;
        i.101 = (unsigned int) i;
        D.25030 = i.101 * 2;
        D.25031 = D.25029 + D.25030;
        D.25032 = *D.25031;
        slot = (int) D.25032;
        D.24912 = class->max_interface_id;
        D.25033 = (int) D.24912;
        D.25034 = D.25033 - interface_id;
        D.25035 = (unsigned int) D.25034;
        D.25036 = D.25035 * 4;
        D.25037 = interface_offsets + D.25036;
        D.25038 = &pvt->vtable[slot];
        *D.25037 = D.25038;
      }
      i = i + 1;
      <D.21798>:
      D.25039 = class->interface_offsets_count;
      D.25040 = (int) D.25039;
      if (D.25040 > i) goto <D.21797>; else goto <D.21799>;
      <D.21799>:
      <D.25024>:
      i = 0;
      goto <D.21802>;
      <D.21801>:
      {
        int interface_id;

        D.25025 = class->interfaces_packed;
        i.101 = (unsigned int) i;
        D.24940 = i.101 * 4;
        D.25026 = D.25025 + D.24940;
        D.25027 = *D.25026;
        D.25028 = D.25027->interface_id;
        interface_id = (int) D.25028;
        D.25041 = interface_id >> 3;
        D.25042 = (sizetype) D.25041;
        D.25043 = bitmap + D.25042;
        D.25041 = interface_id >> 3;
        D.25042 = (sizetype) D.25041;
        D.25043 = bitmap + D.25042;
        D.25044 = *D.25043;
        D.25045 = (signed char) D.25044;
        D.25046 = interface_id & 7;
        D.25047 = 1 << D.25046;
        D.25048 = (signed char) D.25047;
        D.25049 = D.25045 | D.25048;
        D.25050 = (unsigned char) D.25049;
        *D.25043 = D.25050;
      }
      i = i + 1;
      <D.21802>:
      D.25039 = class->interface_offsets_count;
      D.25040 = (int) D.25039;
      if (D.25040 > i) goto <D.21801>; else goto <D.21803>;
      <D.21803>:
      if (extra_interfaces != 0B) goto <D.25051>; else goto <D.25052>;
      <D.25051>:
      {
        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.21813>;
            <D.21812>:
            interf = list_item->data;
            imt_thunk_builder.106 = imt_thunk_builder;
            if (imt_thunk_builder.106 == 0B) goto <D.25053>; else goto <D.25054>;
            <D.25053>:
            D.25055 = interf->interface_id;
            D.25056 = (int) D.25055;
            D.25057 = max_interface_id - D.25056;
            D.25058 = (unsigned int) D.25057;
            D.25059 = D.25058 * 4;
            D.25060 = interface_offsets + D.25059;
            D.25061 = &pvt->vtable[slot];
            *D.25060 = D.25061;
            <D.25054>:
            D.25055 = interf->interface_id;
            D.25062 = D.25055 >> 3;
            D.25063 = (sizetype) D.25062;
            D.25064 = bitmap + D.25063;
            D.25055 = interf->interface_id;
            D.25062 = D.25055 >> 3;
            D.25063 = (sizetype) D.25062;
            D.25064 = bitmap + D.25063;
            D.25065 = *D.25064;
            D.25066 = (signed char) D.25065;
            D.25055 = interf->interface_id;
            D.25056 = (int) D.25055;
            D.25067 = D.25056 & 7;
            D.25068 = 1 << D.25067;
            D.25069 = (signed char) D.25068;
            D.25070 = D.25066 | D.25069;
            D.25071 = (unsigned char) D.25070;
            *D.25064 = D.25071;
            iter = 0B;
            j = 0;
            goto <D.21810>;
            <D.21809>:
            j.111 = j;
            j = j.111 + 1;
            D.25073 = j.111 + slot;
            arch_create_remoting_trampoline.109 = arch_create_remoting_trampoline;
            D.25074 = arch_create_remoting_trampoline.109 (domain, cm, target_type);
            pvt->vtable[D.25073] = D.25074;
            <D.21810>:
            cm = mono_class_get_methods (interf, &iter);
            if (cm != 0B) goto <D.21809>; else goto <D.21811>;
            <D.21811>:
            D.25075 = mono_class_num_methods (interf);
            slot = D.25075 + slot;
            list_item = list_item->next;
            <D.21813>:
            if (list_item != 0B) goto <D.21812>; else goto <D.21814>;
            <D.21814>:
            imt_thunk_builder.106 = imt_thunk_builder;
            if (imt_thunk_builder.106 == 0B) goto <D.25076>; else goto <D.25077>;
            <D.25076>:
            monoeg_g_slist_free (extra_interfaces);
            <D.25077>:
          }
        finally
          {
            iter = {CLOBBER};
          }
      }
      <D.25052>:
      imt_thunk_builder.106 = imt_thunk_builder;
      if (imt_thunk_builder.106 != 0B) goto <D.25078>; else goto <D.25079>;
      <D.25078>:
      build_imt (class, pvt, domain, interface_offsets, extra_interfaces);
      if (extra_interfaces != 0B) goto <D.25080>; else goto <D.25081>;
      <D.25080>:
      monoeg_g_slist_free (extra_interfaces);
      <D.25081>:
      <D.25079>:
      pvt->interface_bitmap = bitmap;
      D.25082 = pvt;
      return D.25082;
    }
  finally
    {
      error = {CLOBBER};
    }
}


mono_upgrade_remote_class (struct MonoDomain * domain, struct MonoObject * proxy_object, struct MonoClass * klass)
{
  union mono_mutex_t * D.25085;
  _Bool D.25088;
  long int D.25089;
  long int D.25090;
  unsigned int D.25093;
  unsigned int D.25094;
  struct MonoClass * D.25097;
  unsigned int i.112;
  unsigned int D.25101;
  struct MonoClass * D.25104;
  _Bool D.25105;
  struct MonoRemoteClass * D.25108;
  struct MonoRemoteClass * D.25109;
  struct MonoRealProxy * D.25110;
  void * D.25111;
  _Bool D.25114;
  long int D.25115;
  long int D.25116;
  struct MonoTransparentProxy * tproxy;
  struct MonoRemoteClass * remote_class;
  gboolean redo_vtable;

  mono_loader_lock ();
  {
    int ret;

    D.25085 = &domain->lock.mutex;
    ret = pthread_mutex_lock (D.25085);
    if (ret != 0) goto <D.25086>; else goto <D.25087>;
    <D.25086>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
    <D.25087>:
    D.25088 = ret != 0;
    D.25089 = (long int) D.25088;
    D.25090 = __builtin_expect (D.25089, 0);
    if (D.25090 != 0) goto <D.25091>; else goto <D.25092>;
    <D.25091>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 2661, "ret == 0");
    <D.25092>:
  }
  tproxy = proxy_object;
  remote_class = tproxy->remote_class;
  D.25093 = klass->flags;
  D.25094 = D.25093 & 32;
  if (D.25094 != 0) goto <D.25095>; else goto <D.25096>;
  <D.25095>:
  {
    int i;

    redo_vtable = 1;
    i = 0;
    goto <D.21914>;
    <D.21913>:
    D.25097 = remote_class->interfaces[i];
    if (D.25097 == klass) goto <D.25098>; else goto <D.25099>;
    <D.25098>:
    redo_vtable = 0;
    <D.25099>:
    i = i + 1;
    <D.21914>:
    i.112 = (unsigned int) i;
    D.25101 = remote_class->interface_count;
    if (i.112 < D.25101) goto <D.25102>; else goto <D.21915>;
    <D.25102>:
    if (redo_vtable != 0) goto <D.21913>; else goto <D.21915>;
    <D.21915>:
  }
  goto <D.25103>;
  <D.25096>:
  D.25104 = remote_class->proxy_class;
  D.25105 = D.25104 != klass;
  redo_vtable = (gboolean) D.25105;
  <D.25103>:
  if (redo_vtable != 0) goto <D.25106>; else goto <D.25107>;
  <D.25106>:
  D.25108 = clone_remote_class (domain, remote_class, klass);
  tproxy->remote_class = D.25108;
  D.25109 = tproxy->remote_class;
  D.25110 = tproxy->rp;
  D.25111 = mono_remote_class_vtable (domain, D.25109, D.25110);
  proxy_object->vtable = D.25111;
  <D.25107>:
  {
    int ret;

    D.25085 = &domain->lock.mutex;
    ret = pthread_mutex_unlock (D.25085);
    if (ret != 0) goto <D.25112>; else goto <D.25113>;
    <D.25112>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.25113>:
    D.25114 = ret != 0;
    D.25115 = (long int) D.25114;
    D.25116 = __builtin_expect (D.25115, 0);
    if (D.25116 != 0) goto <D.25117>; else goto <D.25118>;
    <D.25117>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 2682, "ret == 0");
    <D.25118>:
  }
  mono_loader_unlock ();
}


clone_remote_class (struct MonoDomain * domain, struct MonoRemoteClass * remote_class, struct MonoClass * extra_class)
{
  struct GHashTable * D.25119;
  struct MonoRemoteClass * D.25122;
  unsigned int D.25123;
  unsigned int D.25124;
  unsigned int D.25127;
  unsigned int D.25128;
  unsigned int D.25129;
  struct MonoClass * D.25130;
  unsigned int D.25131;
  struct MonoClass * D.25132;
  int j.113;
  unsigned int i.114;
  unsigned int D.25142;
  unsigned int D.25143;
  unsigned int D.25144;
  struct MonoClass *[0:] * D.25147;
  struct MonoClass *[0:] * D.25148;
  unsigned int D.25149;
  char * D.25150;
  struct MonoRemoteClass * rc;
  void * * key;
  void * * mp_key;

  key = create_remote_class_key (remote_class, extra_class);
  D.25119 = domain->proxy_vtable_hash;
  rc = monoeg_g_hash_table_lookup (D.25119, key);
  if (rc != 0B) goto <D.25120>; else goto <D.25121>;
  <D.25120>:
  monoeg_g_free (key);
  D.25122 = rc;
  return D.25122;
  <D.25121>:
  mp_key = copy_remote_class_key (domain, key);
  monoeg_g_free (key);
  key = mp_key;
  D.25123 = extra_class->flags;
  D.25124 = D.25123 & 32;
  if (D.25124 != 0) goto <D.25125>; else goto <D.25126>;
  <D.25125>:
  {
    int i;
    int j;

    D.25127 = remote_class->interface_count;
    D.25128 = D.25127 + 6;
    D.25129 = D.25128 * 4;
    rc = mono_domain_alloc (domain, D.25129);
    D.25130 = remote_class->proxy_class;
    rc->proxy_class = D.25130;
    D.25127 = remote_class->interface_count;
    D.25131 = D.25127 + 1;
    rc->interface_count = D.25131;
    i = 0;
    j = 0;
    goto <D.21891>;
    <D.21890>:
    D.25132 = remote_class->interfaces[i];
    if (D.25132 > extra_class) goto <D.25133>; else goto <D.25134>;
    <D.25133>:
    if (i == j) goto <D.25135>; else goto <D.25136>;
    <D.25135>:
    j.113 = j;
    j = j.113 + 1;
    rc->interfaces[j.113] = extra_class;
    <D.25136>:
    <D.25134>:
    D.25132 = remote_class->interfaces[i];
    rc->interfaces[j] = D.25132;
    i = i + 1;
    j = j + 1;
    <D.21891>:
    i.114 = (unsigned int) i;
    D.25127 = remote_class->interface_count;
    if (i.114 < D.25127) goto <D.21890>; else goto <D.21892>;
    <D.21892>:
    if (i == j) goto <D.25139>; else goto <D.25140>;
    <D.25139>:
    rc->interfaces[j] = extra_class;
    <D.25140>:
  }
  goto <D.25141>;
  <D.25126>:
  D.25127 = remote_class->interface_count;
  D.25142 = D.25127 + 5;
  D.25143 = D.25142 * 4;
  rc = mono_domain_alloc (domain, D.25143);
  rc->proxy_class = extra_class;
  D.25127 = remote_class->interface_count;
  rc->interface_count = D.25127;
  D.25144 = rc->interface_count;
  if (D.25144 != 0) goto <D.25145>; else goto <D.25146>;
  <D.25145>:
  D.25147 = &rc->interfaces;
  D.25148 = &remote_class->interfaces;
  D.25144 = rc->interface_count;
  D.25149 = D.25144 * 4;
  memcpy (D.25147, D.25148, D.25149);
  <D.25146>:
  <D.25141>:
  rc->default_vtable = 0B;
  rc->xdomain_vtable = 0B;
  D.25150 = remote_class->proxy_class_name;
  rc->proxy_class_name = D.25150;
  D.25119 = domain->proxy_vtable_hash;
  monoeg_g_hash_table_insert_replace (D.25119, key, rc, 0);
  D.25122 = rc;
  return D.25122;
}


mono_object_get_virtual_method (struct MonoObject * obj, struct MonoMethod * method)
{
  struct MonoVTable * D.25152;
  struct MonoClass * D.25153;
  struct MonoRemoteClass * D.25156;
  short unsigned int D.25159;
  unsigned int D.25160;
  unsigned int D.25161;
  struct MonoMethod * D.25164;
  short int D.25165;
  unsigned char D.25168;
  unsigned char D.25169;
  struct MonoMethod * D.25172;
  short int D.25173;
  _Bool D.25174;
  long int D.25175;
  long int D.25176;
  struct MonoClass * D.25184;
  unsigned int D.25185;
  unsigned int D.25186;
  _Bool D.25191;
  long int D.25192;
  long int D.25193;
  int D.25196;
  int D.25197;
  unsigned int D.25198;
  unsigned int D.25199;
  struct MonoMethod * * D.25200;
  unsigned int D.25202;
  unsigned int D.25203;
  struct MonoMethod * * D.25204;
  struct MonoMethodSignature * D.25210;
  short unsigned int D.25211;
  struct MonoMethodSignature * D.25212;
  short unsigned int D.25213;
  struct MonoClass * D.25220;
  unsigned char D.25222;
  unsigned char D.25223;
  struct MonoGenericContext * D.25227;
  _Bool D.25228;
  long int D.25229;
  long int D.25230;
  struct MonoClass * klass;
  struct MonoMethod * * vtable;
  gboolean is_proxy;
  struct MonoMethod * res;

  is_proxy = 0;
  res = 0B;
  D.25152 = obj->vtable;
  klass = D.25152->klass;
  D.25153 = mono_defaults.transparent_proxy_class;
  if (D.25153 == klass) goto <D.25154>; else goto <D.25155>;
  <D.25154>:
  D.25156 = MEM[(struct MonoTransparentProxy *)obj].remote_class;
  klass = D.25156->proxy_class;
  is_proxy = 1;
  <D.25155>:
  if (is_proxy == 0) goto <D.25157>; else goto <D.25158>;
  <D.25157>:
  D.25159 = method->flags;
  D.25160 = (unsigned int) D.25159;
  D.25161 = D.25160 & 96;
  if (D.25161 != 64) goto <D.25162>; else goto <D.25163>;
  <D.25162>:
  D.25164 = method;
  return D.25164;
  <D.25163>:
  <D.25158>:
  mono_class_setup_vtable (klass);
  vtable = klass->vtable;
  D.25165 = method->slot;
  if (D.25165 == -1) goto <D.25166>; else goto <D.25167>;
  <D.25166>:
  D.25168 = BIT_FIELD_REF <*method, 8, 168>;
  D.25169 = D.25168 & 16;
  if (D.25169 != 0) goto <D.25170>; else goto <D.25171>;
  <D.25170>:
  D.25172 = MEM[(struct MonoMethodInflated *)method].declaring;
  D.25173 = D.25172->slot;
  D.25174 = D.25173 == -1;
  D.25175 = (long int) D.25174;
  D.25176 = __builtin_expect (D.25175, 0);
  if (D.25176 != 0) goto <D.25177>; else goto <D.25178>;
  <D.25177>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 2721, "((MonoMethodInflated*)method)->declaring->slot != -1");
  <D.25178>:
  D.25172 = MEM[(struct MonoMethodInflated *)method].declaring;
  D.25173 = D.25172->slot;
  method->slot = D.25173;
  goto <D.25179>;
  <D.25171>:
  if (is_proxy == 0) goto <D.25180>; else goto <D.25181>;
  <D.25180>:
  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "object.c", 2725);
  <D.25181>:
  <D.25179>:
  <D.25167>:
  D.25165 = method->slot;
  if (D.25165 != -1) goto <D.25182>; else goto <D.25183>;
  <D.25182>:
  D.25184 = method->klass;
  D.25185 = D.25184->flags;
  D.25186 = D.25185 & 32;
  if (D.25186 != 0) goto <D.25187>; else goto <D.25188>;
  <D.25187>:
  if (is_proxy == 0) goto <D.25189>; else goto <D.25190>;
  <D.25189>:
  {
    gboolean variance_used;
    int iface_offset;

    try
      {
        variance_used = 0;
        D.25184 = method->klass;
        iface_offset = mono_class_interface_offset_with_variance (klass, D.25184, &variance_used);
        D.25191 = iface_offset <= 0;
        D.25192 = (long int) D.25191;
        D.25193 = __builtin_expect (D.25192, 0);
        if (D.25193 != 0) goto <D.25194>; else goto <D.25195>;
        <D.25194>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 2735, "iface_offset > 0");
        <D.25195>:
        D.25165 = method->slot;
        D.25196 = (int) D.25165;
        D.25197 = D.25196 + iface_offset;
        D.25198 = (unsigned int) D.25197;
        D.25199 = D.25198 * 4;
        D.25200 = vtable + D.25199;
        res = *D.25200;
      }
    finally
      {
        variance_used = {CLOBBER};
      }
  }
  <D.25190>:
  goto <D.25201>;
  <D.25188>:
  D.25165 = method->slot;
  D.25202 = (unsigned int) D.25165;
  D.25203 = D.25202 * 4;
  D.25204 = vtable + D.25203;
  res = *D.25204;
  <D.25201>:
  <D.25183>:
  if (is_proxy != 0) goto <D.25205>; else goto <D.25206>;
  <D.25205>:
  if (res == 0B) goto <D.25207>; else goto <D.25209>;
  <D.25209>:
  D.25210 = mono_method_signature (res);
  D.25211 = D.25210->generic_param_count;
  if (D.25211 != 0) goto <D.25207>; else goto <D.25208>;
  <D.25207>:
  res = method;
  <D.25208>:
  D.25212 = mono_method_signature (res);
  D.25213 = D.25212->generic_param_count;
  if (D.25213 != 0) goto <D.25214>; else goto <D.25215>;
  <D.25214>:
  res = mono_marshal_get_remoting_invoke_with_check (res);
  goto <D.25216>;
  <D.25215>:
  D.25220 = mono_class_get_com_object_class ();
  if (D.25220 == klass) goto <D.25217>; else goto <D.25221>;
  <D.25221>:
  D.25222 = BIT_FIELD_REF <*klass, 8, 184>;
  D.25223 = D.25222 & 64;
  if (D.25223 != 0) goto <D.25217>; else goto <D.25218>;
  <D.25217>:
  res = mono_cominterop_get_invoke (res);
  goto <D.25219>;
  <D.25218>:
  res = mono_marshal_get_remoting_invoke (res);
  <D.25219>:
  <D.25216>:
  goto <D.25224>;
  <D.25206>:
  D.25168 = BIT_FIELD_REF <*method, 8, 168>;
  D.25169 = D.25168 & 16;
  if (D.25169 != 0) goto <D.25225>; else goto <D.25226>;
  <D.25225>:
  D.25227 = &MEM[(struct MonoMethodInflated *)method].context;
  res = mono_class_inflate_generic_method (res, D.25227);
  <D.25226>:
  <D.25224>:
  D.25228 = res == 0B;
  D.25229 = (long int) D.25228;
  D.25230 = __builtin_expect (D.25229, 0);
  if (D.25230 != 0) goto <D.25231>; else goto <D.25232>;
  <D.25231>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 2769, "res");
  <D.25232>:
  D.25164 = res;
  return D.25164;
}


mono_runtime_invoke (struct MonoMethod * method, void * obj, void * * params, struct MonoObject * * exc)
{
  int D.25234;
  char * D.25237;
  <unnamed type> D.25238;
  unsigned int D.25239;
  struct MonoObject * (*<T1c33>) (struct MonoMethod *, void *, void * *, struct MonoObject * *) default_mono_runtime_invoke.115;
  <unnamed type> D.25243;
  unsigned int D.25244;
  struct MonoObject * D.25247;
  struct MonoObject * result;

  D.25234 = mono_runtime_get_no_exec ();
  if (D.25234 != 0) goto <D.25235>; else goto <D.25236>;
  <D.25235>:
  D.25237 = mono_method_full_name (method, 1);
  monoeg_g_log (0B, 16, "Invoking method \'%s\' when running in no-exec mode.\n", D.25237);
  <D.25236>:
  D.25238 = mono_profiler_get_events ();
  D.25239 = D.25238 & 65536;
  if (D.25239 != 0) goto <D.25240>; else goto <D.25241>;
  <D.25240>:
  mono_profiler_method_start_invoke (method);
  <D.25241>:
  default_mono_runtime_invoke.115 = default_mono_runtime_invoke;
  result = default_mono_runtime_invoke.115 (method, obj, params, exc);
  D.25243 = mono_profiler_get_events ();
  D.25244 = D.25243 & 65536;
  if (D.25244 != 0) goto <D.25245>; else goto <D.25246>;
  <D.25245>:
  mono_profiler_method_end_invoke (method);
  <D.25246>:
  D.25247 = result;
  return D.25247;
}


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

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


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

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


mono_field_set_value (struct MonoObject * obj, struct MonoClassField * field, void * value)
{
  struct MonoType * D.25253;
  short unsigned int D.25254;
  int D.25255;
  int D.25256;
  int D.25259;
  sizetype D.25260;
  void * dest;

  D.25253 = field->type;
  D.25254 = D.25253->attrs;
  D.25255 = (int) D.25254;
  D.25256 = D.25255 & 16;
  if (D.25256 != 0) goto <D.25257>; else goto <D.25258>;
  <D.25257>:
  monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "object.c", 3003, "!(field->type->attrs & FIELD_ATTRIBUTE_STATIC)");
  return;
  <D.25258>:
  D.25259 = field->offset;
  D.25260 = (sizetype) D.25259;
  dest = obj + D.25260;
  D.25253 = field->type;
  set_value (D.25253, dest, value, 0);
}


set_value (struct MonoType * type, void * dest, void * value, int deref_pointer)
{
  unsigned char D.25262;
  unsigned char D.25263;
  unsigned char D.25266;
  guint8 iftmp.116;
  guint16 iftmp.117;
  int iftmp.118;
  gint64 iftmp.119;
  float iftmp.120;
  double iftmp.121;
  struct MonoObject * iftmp.122;
  void * iftmp.123;
  struct MonoClass * D.25301;
  unsigned char D.25302;
  unsigned char D.25303;
  struct MonoType * D.25305;
  unsigned char D.25306;
  unsigned int size.124;
  struct MonoGenericClass * D.25311;
  struct MonoClass * D.25312;
  unsigned char D.25313;
  int D.25314;
  int t;
  void handle_enum = <<< error >>>;

  D.25262 = BIT_FIELD_REF <*type, 8, 56>;
  D.25263 = D.25262 & 64;
  if (D.25263 != 0) goto <D.25264>; else goto <D.25265>;
  <D.25264>:
  {
    void * * p;

    p = dest;
    *p = value;
    return;
  }
  <D.25265>:
  D.25266 = type->type;
  t = (int) D.25266;
  handle_enum:
  switch (t) <default: <D.21986>, case 2: <D.21954>, case 3: <D.21960>, case 4: <D.21955>, case 5: <D.21956>, case 6: <D.21958>, case 7: <D.21959>, case 8: <D.21964>, case 9: <D.21965>, case 10: <D.21967>, case 11: <D.21968>, case 12: <D.21970>, case 13: <D.21972>, case 14: <D.21974>, case 15: <D.21980>, case 17: <D.21982>, case 18: <D.21976>, case 20: <D.21978>, case 21: <D.21985>, case 24: <D.21962>, case 25: <D.21963>, case 27: <D.21979>, case 28: <D.21977>, case 29: <D.21975>>
  <D.21954>:
  <D.21955>:
  <D.21956>:
  {
    guint8 * p;

    p = dest;
    if (value != 0B) goto <D.25268>; else goto <D.25269>;
    <D.25268>:
    iftmp.116 = MEM[(guint8 *)value];
    goto <D.25270>;
    <D.25269>:
    iftmp.116 = 0;
    <D.25270>:
    *p = iftmp.116;
    return;
  }
  <D.21958>:
  <D.21959>:
  <D.21960>:
  {
    guint16 * p;

    p = dest;
    if (value != 0B) goto <D.25272>; else goto <D.25273>;
    <D.25272>:
    iftmp.117 = MEM[(guint16 *)value];
    goto <D.25274>;
    <D.25273>:
    iftmp.117 = 0;
    <D.25274>:
    *p = iftmp.117;
    return;
  }
  <D.21962>:
  <D.21963>:
  <D.21964>:
  <D.21965>:
  {
    gint32 * p;

    p = dest;
    if (value != 0B) goto <D.25276>; else goto <D.25277>;
    <D.25276>:
    iftmp.118 = MEM[(gint32 *)value];
    goto <D.25278>;
    <D.25277>:
    iftmp.118 = 0;
    <D.25278>:
    *p = iftmp.118;
    return;
  }
  <D.21967>:
  <D.21968>:
  {
    gint64 * p;

    p = dest;
    if (value != 0B) goto <D.25280>; else goto <D.25281>;
    <D.25280>:
    iftmp.119 = MEM[(gint64 *)value];
    goto <D.25282>;
    <D.25281>:
    iftmp.119 = 0;
    <D.25282>:
    *p = iftmp.119;
    return;
  }
  <D.21970>:
  {
    float * p;

    p = dest;
    if (value != 0B) goto <D.25284>; else goto <D.25285>;
    <D.25284>:
    iftmp.120 = MEM[(float *)value];
    goto <D.25286>;
    <D.25285>:
    iftmp.120 = 0.0;
    <D.25286>:
    *p = iftmp.120;
    return;
  }
  <D.21972>:
  {
    double * p;

    p = dest;
    if (value != 0B) goto <D.25288>; else goto <D.25289>;
    <D.25288>:
    iftmp.121 = MEM[(double *)value];
    goto <D.25290>;
    <D.25289>:
    iftmp.121 = 0.0;
    <D.25290>:
    *p = iftmp.121;
    return;
  }
  <D.21974>:
  <D.21975>:
  <D.21976>:
  <D.21977>:
  <D.21978>:
  if (deref_pointer != 0) goto <D.25292>; else goto <D.25293>;
  <D.25292>:
  iftmp.122 = MEM[(void * *)value];
  goto <D.25294>;
  <D.25293>:
  iftmp.122 = value;
  <D.25294>:
  mono_gc_wbarrier_generic_store (dest, iftmp.122);
  return;
  <D.21979>:
  <D.21980>:
  {
    void * * p;

    p = dest;
    if (deref_pointer != 0) goto <D.25296>; else goto <D.25297>;
    <D.25296>:
    iftmp.123 = MEM[(void * *)value];
    goto <D.25298>;
    <D.25297>:
    iftmp.123 = value;
    <D.25298>:
    *p = iftmp.123;
    return;
  }
  <D.21982>:
  D.25266 = type->type;
  if (D.25266 == 17) goto <D.25300>; else goto <D.25299>;
  <D.25300>:
  D.25301 = type->data.klass;
  D.25302 = BIT_FIELD_REF <*D.25301, 8, 160>;
  D.25303 = D.25302 & 16;
  if (D.25303 != 0) goto <D.25304>; else goto <D.25299>;
  <D.25304>:
  D.25301 = type->data.klass;
  D.25305 = mono_class_enum_basetype (D.25301);
  D.25306 = D.25305->type;
  t = (int) D.25306;
  goto handle_enum;
  <D.25299>:
  {
    struct MonoClass * class;
    int size;

    class = mono_class_from_mono_type (type);
    size = mono_class_value_size (class, 0B);
    if (value == 0B) goto <D.25307>; else goto <D.25308>;
    <D.25307>:
    size.124 = (unsigned int) size;
    mono_gc_bzero_atomic (dest, size.124);
    goto <D.25310>;
    <D.25308>:
    mono_gc_wbarrier_value_copy (dest, value, 1, class);
    <D.25310>:
  }
  return;
  <D.21985>:
  D.25311 = type->data.generic_class;
  D.25312 = D.25311->container_class;
  D.25313 = D.25312->byval_arg.type;
  t = (int) D.25313;
  goto handle_enum;
  <D.21986>:
  D.25266 = type->type;
  D.25314 = (int) D.25266;
  monoeg_g_log (0B, 4, "got type %x", D.25314);
  <D.21987>:
  goto <D.21987>;
}


mono_field_static_set_value (struct MonoVTable * vt, struct MonoClassField * field, void * value)
{
  struct MonoType * D.25316;
  short unsigned int D.25317;
  int D.25318;
  int D.25319;
  int D.25322;
  int D.25325;
  struct MonoDomain * D.25328;
  union mono_mutex_t * D.25329;
  _Bool D.25332;
  long int D.25333;
  long int D.25334;
  struct GHashTable * D.25337;
  _Bool D.25340;
  long int D.25341;
  long int D.25342;
  unsigned int addr.125;
  void * D.25347;
  sizetype D.25348;
  void * dest;

  D.25316 = field->type;
  D.25317 = D.25316->attrs;
  D.25318 = (int) D.25317;
  D.25319 = D.25318 & 16;
  if (D.25319 == 0) goto <D.25320>; else goto <D.25321>;
  <D.25320>:
  monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "object.c", 3024, "field->type->attrs & FIELD_ATTRIBUTE_STATIC");
  return;
  <D.25321>:
  D.25316 = field->type;
  D.25317 = D.25316->attrs;
  D.25318 = (int) D.25317;
  D.25322 = D.25318 & 64;
  if (D.25322 != 0) goto <D.25323>; else goto <D.25324>;
  <D.25323>:
  monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "object.c", 3026, "!(field->type->attrs & FIELD_ATTRIBUTE_LITERAL)");
  return;
  <D.25324>:
  D.25325 = field->offset;
  if (D.25325 == -1) goto <D.25326>; else goto <D.25327>;
  <D.25326>:
  {
    void * addr;

    {
      int ret;

      D.25328 = vt->domain;
      D.25329 = &D.25328->lock.mutex;
      ret = pthread_mutex_lock (D.25329);
      if (ret != 0) goto <D.25330>; else goto <D.25331>;
      <D.25330>:
      monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
      <D.25331>:
      D.25332 = ret != 0;
      D.25333 = (long int) D.25332;
      D.25334 = __builtin_expect (D.25333, 0);
      if (D.25334 != 0) goto <D.25335>; else goto <D.25336>;
      <D.25335>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 3032, "ret == 0");
      <D.25336>:
    }
    D.25328 = vt->domain;
    D.25337 = D.25328->special_static_fields;
    addr = monoeg_g_hash_table_lookup (D.25337, field);
    {
      int ret;

      D.25328 = vt->domain;
      D.25329 = &D.25328->lock.mutex;
      ret = pthread_mutex_unlock (D.25329);
      if (ret != 0) goto <D.25338>; else goto <D.25339>;
      <D.25338>:
      monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
      <D.25339>:
      D.25340 = ret != 0;
      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", 3034, "ret == 0");
      <D.25344>:
    }
    addr.125 = (unsigned int) addr;
    dest = mono_get_special_static_data (addr.125);
  }
  goto <D.25346>;
  <D.25327>:
  D.25347 = mono_vtable_get_static_field_data (vt);
  D.25325 = field->offset;
  D.25348 = (sizetype) D.25325;
  dest = D.25347 + D.25348;
  <D.25346>:
  D.25316 = field->type;
  set_value (D.25316, dest, value, 0);
}


mono_vtable_get_static_field_data (struct MonoVTable * vt)
{
  unsigned char D.25350;
  unsigned char D.25351;
  void * D.25354;
  struct MonoClass * D.25355;
  int D.25356;

  D.25350 = BIT_FIELD_REF <*vt, 8, 184>;
  D.25351 = D.25350 & 8;
  if (D.25351 == 0) goto <D.25352>; else goto <D.25353>;
  <D.25352>:
  D.25354 = 0B;
  return D.25354;
  <D.25353>:
  D.25355 = vt->klass;
  D.25356 = D.25355->vtable_size;
  D.25354 = vt->vtable[D.25356];
  return D.25354;
}


mono_field_get_value (struct MonoObject * obj, struct MonoClassField * field, void * value)
{
  _Bool D.25358;
  long int D.25359;
  long int D.25360;
  struct MonoType * D.25363;
  short unsigned int D.25364;
  int D.25365;
  int D.25366;
  int D.25369;
  sizetype D.25370;
  void * src;

  D.25358 = obj == 0B;
  D.25359 = (long int) D.25358;
  D.25360 = __builtin_expect (D.25359, 0);
  if (D.25360 != 0) goto <D.25361>; else goto <D.25362>;
  <D.25361>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 3103, "obj");
  <D.25362>:
  D.25363 = field->type;
  D.25364 = D.25363->attrs;
  D.25365 = (int) D.25364;
  D.25366 = D.25365 & 16;
  if (D.25366 != 0) goto <D.25367>; else goto <D.25368>;
  <D.25367>:
  monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "object.c", 3105, "!(field->type->attrs & FIELD_ATTRIBUTE_STATIC)");
  return;
  <D.25368>:
  D.25369 = field->offset;
  D.25370 = (sizetype) D.25369;
  src = obj + D.25370;
  D.25363 = field->type;
  set_value (D.25363, value, src, 1);
}


mono_field_get_value_object (struct MonoDomain * domain, struct MonoClassField * field, struct MonoObject * obj)
{
  int D.25372;
  unsigned char D.25375;
  int D.25376;
  <unnamed-unsigned:1> D.25377;
  int D.25378;
  _Bool D.25379;
  struct MonoObject * D.25380;
  short unsigned int D.25381;
  int D.25382;
  int D.25383;
  int D.25386;
  struct MonoClass * D.25391;
  unsigned char D.25392;
  unsigned char D.25393;
  _Bool D.25397;
  long int D.25398;
  long int D.25399;
  struct MonoMethod * m.126;
  struct MonoClass * ptr_klass.129;
  struct MonoClass * tmp_klass.127;
  struct MonoImage * D.25420;
  struct MonoClass * tmp_klass.128;
  _Bool D.25422;
  long int D.25423;
  long int D.25424;
  struct MonoMethod * m.130;
  _Bool D.25428;
  long int D.25429;
  long int D.25430;
  void * * ptr.131;
  void * D.25440;
  struct MonoDomain * D.25441;
  struct MonoReflectionType * D.25442;
  int D.25443;
  guint8 * D.25446;
  struct MonoObject * o.132;
  struct MonoObject * o.133;
  struct MonoObject * o;
  struct MonoClass * klass;
  struct MonoVTable * vtable;
  gchar * v;
  gboolean is_static;
  gboolean is_ref;
  gboolean is_literal;
  gboolean is_ptr;
  struct MonoError error;
  struct MonoType * type;

  try
    {
      vtable = 0B;
      is_static = 0;
      is_ref = 0;
      is_literal = 0;
      is_ptr = 0;
      type = mono_field_get_type_checked (field, &error);
      D.25372 = mono_error_ok (&error);
      if (D.25372 == 0) goto <D.25373>; else goto <D.25374>;
      <D.25373>:
      mono_error_raise_exception (&error);
      <D.25374>:
      D.25375 = type->type;
      D.25376 = (int) D.25375;
      switch (D.25376) <default: <D.22059>, case 2: <D.22044>, case 3: <D.22047>, case 4: <D.22043>, case 5: <D.22042>, case 6: <D.22046>, case 7: <D.22045>, case 8: <D.22051>, case 9: <D.22050>, case 10: <D.22054>, case 11: <D.22053>, case 12: <D.22052>, case 13: <D.22055>, case 14: <D.22036>, case 15: <D.22058>, case 17: <D.22056>, case 18: <D.22038>, case 20: <D.22039>, case 21: <D.22057>, case 24: <D.22049>, case 25: <D.22048>, case 28: <D.22037>, case 29: <D.22040>>
      <D.22036>:
      <D.22037>:
      <D.22038>:
      <D.22039>:
      <D.22040>:
      is_ref = 1;
      goto <D.22041>;
      <D.22042>:
      <D.22043>:
      <D.22044>:
      <D.22045>:
      <D.22046>:
      <D.22047>:
      <D.22048>:
      <D.22049>:
      <D.22050>:
      <D.22051>:
      <D.22052>:
      <D.22053>:
      <D.22054>:
      <D.22055>:
      <D.22056>:
      D.25377 = type->byref;
      is_ref = (gboolean) D.25377;
      goto <D.22041>;
      <D.22057>:
      D.25378 = mono_type_generic_inst_is_valuetype (type);
      D.25379 = D.25378 == 0;
      is_ref = (gboolean) D.25379;
      goto <D.22041>;
      <D.22058>:
      is_ptr = 1;
      goto <D.22041>;
      <D.22059>:
      D.25375 = type->type;
      D.25376 = (int) D.25375;
      monoeg_g_log (0B, 4, "type 0x%x not handled in mono_field_get_value_object", D.25376);
      <D.22060>:
      goto <D.22060>;
      D.25380 = 0B;
      return D.25380;
      <D.22041>:
      D.25381 = type->attrs;
      D.25382 = (int) D.25381;
      D.25383 = D.25382 & 64;
      if (D.25383 != 0) goto <D.25384>; else goto <D.25385>;
      <D.25384>:
      is_literal = 1;
      <D.25385>:
      D.25381 = type->attrs;
      D.25382 = (int) D.25381;
      D.25386 = D.25382 & 16;
      if (D.25386 != 0) goto <D.25387>; else goto <D.25388>;
      <D.25387>:
      is_static = 1;
      if (is_literal == 0) goto <D.25389>; else goto <D.25390>;
      <D.25389>:
      D.25391 = field->parent;
      vtable = mono_class_vtable_full (domain, D.25391, 1);
      D.25392 = BIT_FIELD_REF <*vtable, 8, 184>;
      D.25393 = D.25392 & 2;
      if (D.25393 == 0) goto <D.25394>; else goto <D.25395>;
      <D.25394>:
      mono_runtime_class_init (vtable);
      <D.25395>:
      <D.25390>:
      goto <D.25396>;
      <D.25388>:
      D.25397 = obj == 0B;
      D.25398 = (long int) D.25397;
      D.25399 = __builtin_expect (D.25398, 0);
      if (D.25399 != 0) goto <D.25400>; else goto <D.25401>;
      <D.25400>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 3187, "obj");
      <D.25401>:
      <D.25396>:
      if (is_ref != 0) goto <D.25402>; else goto <D.25403>;
      <D.25402>:
      if (is_literal != 0) goto <D.25404>; else goto <D.25405>;
      <D.25404>:
      get_default_field_value (domain, field, &o);
      goto <D.25406>;
      <D.25405>:
      if (is_static != 0) goto <D.25407>; else goto <D.25408>;
      <D.25407>:
      mono_field_static_get_value (vtable, field, &o);
      goto <D.25409>;
      <D.25408>:
      mono_field_get_value (obj, field, &o);
      <D.25409>:
      <D.25406>:
      D.25380 = o;
      return D.25380;
      <D.25403>:
      if (is_ptr != 0) goto <D.25410>; else goto <D.25411>;
      <D.25410>:
      {
        static struct MonoMethod * m;
        void * args[2];
        void * * ptr;
        void * v;

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

              {
                static struct MonoClass * tmp_klass;

                {
                  tmp_klass.127 = tmp_klass;
                  if (tmp_klass.127 == 0B) goto <D.25416>; else goto <D.25417>;
                  <D.25416>:
                  if (0 != 0) goto <D.25418>; else goto <D.25419>;
                  <D.25418>:
                  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 3208, "mono_defaults.corlib == mono_defaults.corlib");
                  <D.25419>:
                  D.25420 = mono_defaults.corlib;
                  tmp_klass.128 = mono_class_from_name (D.25420, "System.Reflection", "Pointer");
                  tmp_klass = tmp_klass.128;
                  tmp_klass.127 = tmp_klass;
                  D.25422 = tmp_klass.127 == 0B;
                  D.25423 = (long int) D.25422;
                  D.25424 = __builtin_expect (D.25423, 0);
                  if (D.25424 != 0) goto <D.25425>; else goto <D.25426>;
                  <D.25425>:
                  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 3208, "tmp_klass");
                  <D.25426>:
                  <D.25417>:
                }
                ptr_klass.129 = tmp_klass;
              }
              ptr_klass = ptr_klass.129;
              m.130 = mono_class_get_method_from_name_flags (ptr_klass, "Box", 2, 16);
              m = m.130;
              m.126 = m;
              D.25428 = m.126 == 0B;
              D.25429 = (long int) D.25428;
              D.25430 = __builtin_expect (D.25429, 0);
              if (D.25430 != 0) goto <D.25431>; else goto <D.25432>;
              <D.25431>:
              monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 3210, "m");
              <D.25432>:
            }
            <D.25414>:
            v = &ptr;
            if (is_literal != 0) goto <D.25433>; else goto <D.25434>;
            <D.25433>:
            get_default_field_value (domain, field, v);
            goto <D.25435>;
            <D.25434>:
            if (is_static != 0) goto <D.25436>; else goto <D.25437>;
            <D.25436>:
            mono_field_static_get_value (vtable, field, v);
            goto <D.25438>;
            <D.25437>:
            mono_field_get_value (obj, field, v);
            <D.25438>:
            <D.25435>:
            ptr.131 = ptr;
            D.25440 = *ptr.131;
            args[0] = D.25440;
            D.25441 = mono_domain_get ();
            D.25442 = mono_type_get_object (D.25441, type);
            args[1] = D.25442;
            m.126 = m;
            D.25380 = mono_runtime_invoke (m.126, 0B, &args, 0B);
            return D.25380;
          }
        finally
          {
            args = {CLOBBER};
            ptr = {CLOBBER};
          }
      }
      <D.25411>:
      klass = mono_class_from_mono_type (type);
      D.25443 = mono_class_is_nullable (klass);
      if (D.25443 != 0) goto <D.25444>; else goto <D.25445>;
      <D.25444>:
      D.25446 = mono_field_get_addr (obj, vtable, field);
      D.25380 = mono_nullable_box (D.25446, klass);
      return D.25380;
      <D.25445>:
      o.132 = mono_object_new (domain, klass);
      o = o.132;
      o.133 = o;
      v = o.133 + 8;
      if (is_literal != 0) goto <D.25449>; else goto <D.25450>;
      <D.25449>:
      get_default_field_value (domain, field, v);
      goto <D.25451>;
      <D.25450>:
      if (is_static != 0) goto <D.25452>; else goto <D.25453>;
      <D.25452>:
      mono_field_static_get_value (vtable, field, v);
      goto <D.25454>;
      <D.25453>:
      mono_field_get_value (obj, field, v);
      <D.25454>:
      <D.25451>:
      D.25380 = o;
      return D.25380;
    }
  finally
    {
      o = {CLOBBER};
      error = {CLOBBER};
    }
}


mono_field_get_addr (struct MonoObject * obj, struct MonoVTable * vt, struct MonoClassField * field)
{
  struct MonoType * D.25458;
  short unsigned int D.25459;
  int D.25460;
  int D.25461;
  int D.25464;
  struct MonoDomain * D.25467;
  union mono_mutex_t * D.25468;
  _Bool D.25471;
  long int D.25472;
  long int D.25473;
  struct GHashTable * D.25476;
  _Bool D.25479;
  long int D.25480;
  long int D.25481;
  unsigned int addr.134;
  void * D.25486;
  sizetype D.25487;
  guint8 * D.25489;
  guint8 * src;

  D.25458 = field->type;
  D.25459 = D.25458->attrs;
  D.25460 = (int) D.25459;
  D.25461 = D.25460 & 16;
  if (D.25461 != 0) goto <D.25462>; else goto <D.25463>;
  <D.25462>:
  D.25464 = field->offset;
  if (D.25464 == -1) goto <D.25465>; else goto <D.25466>;
  <D.25465>:
  {
    void * addr;

    {
      int ret;

      D.25467 = vt->domain;
      D.25468 = &D.25467->lock.mutex;
      ret = pthread_mutex_lock (D.25468);
      if (ret != 0) goto <D.25469>; else goto <D.25470>;
      <D.25469>:
      monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
      <D.25470>:
      D.25471 = ret != 0;
      D.25472 = (long int) D.25471;
      D.25473 = __builtin_expect (D.25472, 0);
      if (D.25473 != 0) goto <D.25474>; else goto <D.25475>;
      <D.25474>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 3067, "ret == 0");
      <D.25475>:
    }
    D.25467 = vt->domain;
    D.25476 = D.25467->special_static_fields;
    addr = monoeg_g_hash_table_lookup (D.25476, field);
    {
      int ret;

      D.25467 = vt->domain;
      D.25468 = &D.25467->lock.mutex;
      ret = pthread_mutex_unlock (D.25468);
      if (ret != 0) goto <D.25477>; else goto <D.25478>;
      <D.25477>:
      monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
      <D.25478>:
      D.25479 = ret != 0;
      D.25480 = (long int) D.25479;
      D.25481 = __builtin_expect (D.25480, 0);
      if (D.25481 != 0) goto <D.25482>; else goto <D.25483>;
      <D.25482>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 3069, "ret == 0");
      <D.25483>:
    }
    addr.134 = (unsigned int) addr;
    src = mono_get_special_static_data (addr.134);
  }
  goto <D.25485>;
  <D.25466>:
  D.25486 = mono_vtable_get_static_field_data (vt);
  D.25464 = field->offset;
  D.25487 = (sizetype) D.25464;
  src = D.25486 + D.25487;
  <D.25485>:
  goto <D.25488>;
  <D.25463>:
  D.25464 = field->offset;
  D.25487 = (sizetype) D.25464;
  src = obj + D.25487;
  <D.25488>:
  D.25489 = src;
  return D.25489;
}


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

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


mono_get_constant_value_from_blob (struct MonoDomain * domain, MonoTypeEnum type, const char * blob, void * value)
{
  const char * p.136;
  char D.25493;
  short unsigned int D.25494;
  unsigned int D.25495;
  long long unsigned int D.25496;
  unsigned int D.25497;
  float D.25498;
  long long unsigned int D.25499;
  double D.25500;
  struct MonoString * D.25501;
  int D.25502;
  int retval;
  const char * p;

  try
    {
      retval = 0;
      p = blob;
      p.136 = p;
      mono_metadata_decode_blob_size (p.136, &p);
      switch (type) <default: <D.22093>, case 2: <D.22076>, case 3: <D.22080>, case 4: <D.22078>, case 5: <D.22077>, case 6: <D.22082>, case 7: <D.22081>, case 8: <D.22084>, case 9: <D.22083>, case 10: <D.22086>, case 11: <D.22085>, case 12: <D.22087>, case 13: <D.22089>, case 14: <D.22091>, case 18: <D.22092>>
      <D.22076>:
      <D.22077>:
      <D.22078>:
      p.136 = p;
      D.25493 = *p.136;
      MEM[(guint8 *)value] = D.25493;
      goto <D.22079>;
      <D.22080>:
      <D.22081>:
      <D.22082>:
      p.136 = p;
      D.25494 = mono_read16 (p.136);
      MEM[(guint16 *)value] = D.25494;
      goto <D.22079>;
      <D.22083>:
      <D.22084>:
      p.136 = p;
      D.25495 = mono_read32 (p.136);
      MEM[(guint32 *)value] = D.25495;
      goto <D.22079>;
      <D.22085>:
      <D.22086>:
      p.136 = p;
      D.25496 = mono_read64 (p.136);
      MEM[(guint64 *)value] = D.25496;
      goto <D.22079>;
      <D.22087>:
      {
        union mono_rfloat mf;

        try
          {
            p.136 = p;
            D.25497 = mono_read32 (p.136);
            mf.ival = D.25497;
            D.25498 = mf.fval;
            MEM[(float *)value] = D.25498;
          }
        finally
          {
            mf = {CLOBBER};
          }
      }
      goto <D.22079>;
      <D.22089>:
      {
        union mono_rdouble mf;

        try
          {
            p.136 = p;
            D.25499 = mono_read64 (p.136);
            mf.ival = D.25499;
            D.25500 = mf.fval;
            MEM[(double *)value] = D.25500;
          }
        finally
          {
            mf = {CLOBBER};
          }
      }
      goto <D.22079>;
      <D.22091>:
      D.25501 = mono_ldstr_metadata_sig (domain, blob);
      MEM[(void * *)value] = D.25501;
      goto <D.22079>;
      <D.22092>:
      MEM[(void * *)value] = 0B;
      goto <D.22079>;
      <D.22093>:
      retval = -1;
      monoeg_g_log (0B, 16, "type 0x%02x should not be in constant table", type);
      <D.22079>:
      D.25502 = retval;
      return D.25502;
    }
  finally
    {
      p = {CLOBBER};
    }
}


mono_ldstr_metadata_sig (struct MonoDomain * domain, const char * sig)
{
  const char * str.137;
  int len2.138;
  _Bool D.25509;
  long int D.25510;
  long int D.25511;
  struct MonoGHashTable * D.25514;
  _Bool D.25519;
  long int D.25520;
  long int D.25521;
  struct MonoString * D.25524;
  _Bool D.25529;
  long int D.25530;
  long int D.25531;
  const char * str;
  struct MonoString * o;
  struct MonoString * interned;
  size_t len2;

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

        ret = pthread_mutex_lock (&ldstr_section.mutex);
        if (ret != 0) goto <D.25507>; else goto <D.25508>;
        <D.25507>:
        monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
        <D.25508>:
        D.25509 = ret != 0;
        D.25510 = (long int) D.25509;
        D.25511 = __builtin_expect (D.25510, 0);
        if (D.25511 != 0) goto <D.25512>; else goto <D.25513>;
        <D.25512>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 5487, "ret == 0");
        <D.25513>:
      }
      D.25514 = domain->ldstr_table;
      interned = mono_g_hash_table_lookup (D.25514, o);
      if (interned != 0B) goto <D.25515>; else goto <D.25516>;
      <D.25515>:
      {
        int ret;

        ret = pthread_mutex_unlock (&ldstr_section.mutex);
        if (ret != 0) goto <D.25517>; else goto <D.25518>;
        <D.25517>:
        monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
        <D.25518>:
        D.25519 = ret != 0;
        D.25520 = (long int) D.25519;
        D.25521 = __builtin_expect (D.25520, 0);
        if (D.25521 != 0) goto <D.25522>; else goto <D.25523>;
        <D.25522>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 5489, "ret == 0");
        <D.25523>:
      }
      D.25524 = interned;
      return D.25524;
      <D.25516>:
      o = mono_string_get_pinned (o);
      if (o != 0B) goto <D.25525>; else goto <D.25526>;
      <D.25525>:
      D.25514 = domain->ldstr_table;
      mono_g_hash_table_insert (D.25514, o, o);
      <D.25526>:
      {
        int ret;

        ret = pthread_mutex_unlock (&ldstr_section.mutex);
        if (ret != 0) goto <D.25527>; else goto <D.25528>;
        <D.25527>:
        monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
        <D.25528>:
        D.25529 = ret != 0;
        D.25530 = (long int) D.25529;
        D.25531 = __builtin_expect (D.25530, 0);
        if (D.25531 != 0) goto <D.25532>; else goto <D.25533>;
        <D.25532>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 5497, "ret == 0");
        <D.25533>:
      }
      D.25524 = o;
      return D.25524;
    }
  finally
    {
      str = {CLOBBER};
    }
}


mono_string_get_pinned (struct MonoString * str)
{
  int D.25536;
  int D.25537;
  int D.25538;
  unsigned int D.25539;
  unsigned int D.25540;
  struct MonoVTable * D.25541;
  unsigned int size.139;
  mono_unichar2 * D.25545;
  mono_unichar2 * D.25546;
  int D.25547;
  int D.25548;
  unsigned int D.25549;
  int D.25550;
  struct MonoString * D.25551;
  int size;
  struct MonoString * news;

  D.25536 = mono_string_length (str);
  D.25537 = D.25536 + 1;
  D.25538 = D.25537 * 2;
  D.25539 = (unsigned int) D.25538;
  D.25540 = D.25539 + 12;
  size = (int) D.25540;
  D.25541 = MEM[(struct MonoObject *)str].vtable;
  size.139 = (unsigned int) size;
  news = mono_gc_alloc_pinned_obj (D.25541, size.139);
  if (news != 0B) goto <D.25543>; else goto <D.25544>;
  <D.25543>:
  D.25545 = mono_string_chars (news);
  D.25546 = mono_string_chars (str);
  D.25547 = mono_string_length (str);
  D.25548 = D.25547 * 2;
  D.25549 = (unsigned int) D.25548;
  memcpy (D.25545, D.25546, D.25549);
  D.25550 = mono_string_length (str);
  news->length = D.25550;
  <D.25544>:
  D.25551 = news;
  return D.25551;
}


mono_field_static_get_value_for_thread (struct MonoInternalThread * thread, struct MonoVTable * vt, struct MonoClassField * field, void * value)
{
  struct MonoType * D.25553;
  short unsigned int D.25554;
  int D.25555;
  int D.25556;
  int D.25559;
  struct MonoDomain * D.25562;
  int D.25563;
  struct GHashTable * D.25566;
  unsigned int addr.140;
  void * D.25569;
  sizetype D.25570;
  void * src;

  D.25553 = field->type;
  D.25554 = D.25553->attrs;
  D.25555 = (int) D.25554;
  D.25556 = D.25555 & 16;
  if (D.25556 == 0) goto <D.25557>; else goto <D.25558>;
  <D.25557>:
  monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "object.c", 3309, "field->type->attrs & FIELD_ATTRIBUTE_STATIC");
  return;
  <D.25558>:
  D.25553 = field->type;
  D.25554 = D.25553->attrs;
  D.25555 = (int) D.25554;
  D.25559 = D.25555 & 64;
  if (D.25559 != 0) goto <D.25560>; else goto <D.25561>;
  <D.25560>:
  D.25562 = vt->domain;
  get_default_field_value (D.25562, field, value);
  return;
  <D.25561>:
  D.25563 = field->offset;
  if (D.25563 == -1) goto <D.25564>; else goto <D.25565>;
  <D.25564>:
  {
    void * addr;

    D.25562 = vt->domain;
    D.25566 = D.25562->special_static_fields;
    addr = monoeg_g_hash_table_lookup (D.25566, field);
    addr.140 = (unsigned int) addr;
    src = mono_get_special_static_data_for_thread (thread, addr.140);
  }
  goto <D.25568>;
  <D.25565>:
  D.25569 = mono_vtable_get_static_field_data (vt);
  D.25563 = field->offset;
  D.25570 = (sizetype) D.25563;
  src = D.25569 + D.25570;
  <D.25568>:
  D.25553 = field->type;
  set_value (D.25553, value, src, 1);
}


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

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


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

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


mono_property_get_value (struct MonoProperty * prop, void * obj, void * * params, struct MonoObject * * exc)
{
  struct MonoObject * D.25576;
  struct MonoObject * (*<T1c33>) (struct MonoMethod *, void *, void * *, struct MonoObject * *) default_mono_runtime_invoke.142;
  struct MonoMethod * D.25578;

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


mono_nullable_init (guint8 * buf, struct MonoObject * value, struct MonoClass * klass)
{
  unsigned char D.25580;
  unsigned char D.25581;
  _Bool D.25582;
  long int D.25583;
  long int D.25584;
  struct MonoClassField * D.25587;
  struct MonoType * D.25588;
  struct MonoClass * D.25589;
  _Bool D.25590;
  long int D.25591;
  long int D.25592;
  struct MonoClassField * D.25595;
  struct MonoType * D.25596;
  struct MonoClass * D.25597;
  struct MonoClass * D.25598;
  _Bool D.25599;
  long int D.25600;
  long int D.25601;
  int D.25604;
  sizetype D.25605;
  sizetype D.25606;
  guint8 * D.25607;
  _Bool D.25608;
  unsigned char D.25609;
  unsigned char D.25612;
  unsigned char D.25613;
  int D.25616;
  sizetype D.25617;
  sizetype D.25618;
  guint8 * D.25619;
  void * D.25620;
  void * D.25622;
  int D.25623;
  unsigned int D.25624;
  int D.25626;
  unsigned int D.25627;
  struct MonoClass * param_class;

  param_class = klass->cast_class;
  mono_class_setup_fields_locking (klass);
  D.25580 = BIT_FIELD_REF <*klass, 8, 192>;
  D.25581 = D.25580 & 32;
  D.25582 = D.25581 == 0;
  D.25583 = (long int) D.25582;
  D.25584 = __builtin_expect (D.25583, 0);
  if (D.25584 != 0) goto <D.25585>; else goto <D.25586>;
  <D.25585>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 3412, "klass->fields_inited");
  <D.25586>:
  D.25587 = klass->fields;
  D.25588 = D.25587->type;
  D.25589 = mono_class_from_mono_type (D.25588);
  D.25590 = D.25589 != param_class;
  D.25591 = (long int) D.25590;
  D.25592 = __builtin_expect (D.25591, 0);
  if (D.25592 != 0) goto <D.25593>; else goto <D.25594>;
  <D.25593>:
  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.25594>:
  D.25587 = klass->fields;
  D.25595 = D.25587 + 16;
  D.25596 = D.25595->type;
  D.25597 = mono_class_from_mono_type (D.25596);
  D.25598 = mono_defaults.boolean_class;
  D.25599 = D.25597 != D.25598;
  D.25600 = (long int) D.25599;
  D.25601 = __builtin_expect (D.25600, 0);
  if (D.25601 != 0) goto <D.25602>; else goto <D.25603>;
  <D.25602>:
  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.25603>:
  D.25587 = klass->fields;
  D.25595 = D.25587 + 16;
  D.25604 = D.25595->offset;
  D.25605 = (sizetype) D.25604;
  D.25606 = D.25605 + 4294967288;
  D.25607 = buf + D.25606;
  D.25608 = value != 0B;
  D.25609 = (unsigned char) D.25608;
  *D.25607 = D.25609;
  if (value != 0B) goto <D.25610>; else goto <D.25611>;
  <D.25610>:
  D.25612 = BIT_FIELD_REF <*param_class, 8, 184>;
  D.25613 = D.25612 & 8;
  if (D.25613 != 0) goto <D.25614>; else goto <D.25615>;
  <D.25614>:
  D.25587 = klass->fields;
  D.25616 = D.25587->offset;
  D.25617 = (sizetype) D.25616;
  D.25618 = D.25617 + 4294967288;
  D.25619 = buf + D.25618;
  D.25620 = mono_object_unbox (value);
  mono_gc_wbarrier_value_copy (D.25619, D.25620, 1, param_class);
  goto <D.25621>;
  <D.25615>:
  D.25587 = klass->fields;
  D.25616 = D.25587->offset;
  D.25617 = (sizetype) D.25616;
  D.25618 = D.25617 + 4294967288;
  D.25619 = buf + D.25618;
  D.25622 = mono_object_unbox (value);
  D.25623 = mono_class_value_size (param_class, 0B);
  D.25624 = (unsigned int) D.25623;
  mono_gc_memmove_atomic (D.25619, D.25622, D.25624);
  <D.25621>:
  goto <D.25625>;
  <D.25611>:
  D.25587 = klass->fields;
  D.25616 = D.25587->offset;
  D.25617 = (sizetype) D.25616;
  D.25618 = D.25617 + 4294967288;
  D.25619 = buf + D.25618;
  D.25626 = mono_class_value_size (param_class, 0B);
  D.25627 = (unsigned int) D.25626;
  mono_gc_bzero_atomic (D.25619, D.25627);
  <D.25625>:
}


mono_nullable_box (guint8 * buf, struct MonoClass * klass)
{
  unsigned char D.25628;
  unsigned char D.25629;
  _Bool D.25630;
  long int D.25631;
  long int D.25632;
  struct MonoClassField * D.25635;
  struct MonoType * D.25636;
  struct MonoClass * D.25637;
  _Bool D.25638;
  long int D.25639;
  long int D.25640;
  struct MonoClassField * D.25643;
  struct MonoType * D.25644;
  struct MonoClass * D.25645;
  struct MonoClass * D.25646;
  _Bool D.25647;
  long int D.25648;
  long int D.25649;
  int D.25652;
  sizetype D.25653;
  sizetype D.25654;
  guint8 * D.25655;
  unsigned char D.25656;
  struct MonoDomain * D.25659;
  unsigned char D.25660;
  unsigned char D.25661;
  void * D.25664;
  int D.25665;
  sizetype D.25666;
  sizetype D.25667;
  guint8 * D.25668;
  void * D.25670;
  int D.25671;
  unsigned int D.25672;
  struct MonoObject * D.25673;
  struct MonoClass * param_class;

  param_class = klass->cast_class;
  mono_class_setup_fields_locking (klass);
  D.25628 = BIT_FIELD_REF <*klass, 8, 192>;
  D.25629 = D.25628 & 32;
  D.25630 = D.25629 == 0;
  D.25631 = (long int) D.25630;
  D.25632 = __builtin_expect (D.25631, 0);
  if (D.25632 != 0) goto <D.25633>; else goto <D.25634>;
  <D.25633>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 3442, "klass->fields_inited");
  <D.25634>:
  D.25635 = klass->fields;
  D.25636 = D.25635->type;
  D.25637 = mono_class_from_mono_type (D.25636);
  D.25638 = D.25637 != param_class;
  D.25639 = (long int) D.25638;
  D.25640 = __builtin_expect (D.25639, 0);
  if (D.25640 != 0) goto <D.25641>; else goto <D.25642>;
  <D.25641>:
  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.25642>:
  D.25635 = klass->fields;
  D.25643 = D.25635 + 16;
  D.25644 = D.25643->type;
  D.25645 = mono_class_from_mono_type (D.25644);
  D.25646 = mono_defaults.boolean_class;
  D.25647 = D.25645 != D.25646;
  D.25648 = (long int) D.25647;
  D.25649 = __builtin_expect (D.25648, 0);
  if (D.25649 != 0) goto <D.25650>; else goto <D.25651>;
  <D.25650>:
  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.25651>:
  D.25635 = klass->fields;
  D.25643 = D.25635 + 16;
  D.25652 = D.25643->offset;
  D.25653 = (sizetype) D.25652;
  D.25654 = D.25653 + 4294967288;
  D.25655 = buf + D.25654;
  D.25656 = *D.25655;
  if (D.25656 != 0) goto <D.25657>; else goto <D.25658>;
  <D.25657>:
  {
    struct MonoObject * o;

    D.25659 = mono_domain_get ();
    o = mono_object_new (D.25659, param_class);
    D.25660 = BIT_FIELD_REF <*param_class, 8, 184>;
    D.25661 = D.25660 & 8;
    if (D.25661 != 0) goto <D.25662>; else goto <D.25663>;
    <D.25662>:
    D.25664 = mono_object_unbox (o);
    D.25635 = klass->fields;
    D.25665 = D.25635->offset;
    D.25666 = (sizetype) D.25665;
    D.25667 = D.25666 + 4294967288;
    D.25668 = buf + D.25667;
    mono_gc_wbarrier_value_copy (D.25664, D.25668, 1, param_class);
    goto <D.25669>;
    <D.25663>:
    D.25670 = mono_object_unbox (o);
    D.25635 = klass->fields;
    D.25665 = D.25635->offset;
    D.25666 = (sizetype) D.25665;
    D.25667 = D.25666 + 4294967288;
    D.25668 = buf + D.25667;
    D.25671 = mono_class_value_size (param_class, 0B);
    D.25672 = (unsigned int) D.25671;
    mono_gc_memmove_atomic (D.25670, D.25668, D.25672);
    <D.25669>:
    D.25673 = o;
    return D.25673;
  }
  <D.25658>:
  D.25673 = 0B;
  return D.25673;
}


mono_get_delegate_invoke (struct MonoClass * klass)
{
  unsigned char D.25675;
  struct MonoMethod * D.25678;
  struct MonoMethod * im;

  mono_class_setup_methods (klass);
  D.25675 = klass->exception_type;
  if (D.25675 != 0) goto <D.25676>; else goto <D.25677>;
  <D.25676>:
  D.25678 = 0B;
  return D.25678;
  <D.25677>:
  im = mono_class_get_method_from_name (klass, "Invoke", -1);
  D.25678 = im;
  return D.25678;
}


mono_get_delegate_begin_invoke (struct MonoClass * klass)
{
  unsigned char D.25680;
  struct MonoMethod * D.25683;
  struct MonoMethod * im;

  mono_class_setup_methods (klass);
  D.25680 = klass->exception_type;
  if (D.25680 != 0) goto <D.25681>; else goto <D.25682>;
  <D.25681>:
  D.25683 = 0B;
  return D.25683;
  <D.25682>:
  im = mono_class_get_method_from_name (klass, "BeginInvoke", -1);
  D.25683 = im;
  return D.25683;
}


mono_get_delegate_end_invoke (struct MonoClass * klass)
{
  unsigned char D.25685;
  struct MonoMethod * D.25688;
  struct MonoMethod * im;

  mono_class_setup_methods (klass);
  D.25685 = klass->exception_type;
  if (D.25685 != 0) goto <D.25686>; else goto <D.25687>;
  <D.25686>:
  D.25688 = 0B;
  return D.25688;
  <D.25687>:
  im = mono_class_get_method_from_name (klass, "EndInvoke", -1);
  D.25688 = im;
  return D.25688;
}


mono_runtime_delegate_invoke (struct MonoObject * delegate, void * * params, struct MonoObject * * exc)
{
  struct MonoVTable * D.25690;
  char * D.25693;
  struct MonoObject * D.25694;
  struct MonoMethod * im;
  struct MonoClass * klass;

  D.25690 = delegate->vtable;
  klass = D.25690->klass;
  im = mono_get_delegate_invoke (klass);
  if (im == 0B) goto <D.25691>; else goto <D.25692>;
  <D.25691>:
  D.25693 = mono_type_get_full_name (klass);
  monoeg_g_log (0B, 4, "Could not lookup delegate invoke method for delegate %s", D.25693);
  <D.22157>:
  goto <D.22157>;
  <D.25692>:
  D.25694 = mono_runtime_invoke (im, delegate, params, exc);
  return D.25694;
}


mono_runtime_get_main_args ()
{
  char * * main_args.143;
  struct MonoArray * D.25699;
  struct MonoClass * D.25700;
  int num_main_args.144;
  unsigned int num_main_args.145;
  unsigned int i.146;
  unsigned int i.147;
  unsigned int D.25705;
  char * * D.25706;
  char * D.25707;
  struct MonoString * D.25708;
  struct MonoArray * res;
  int i;
  struct MonoDomain * domain;

  domain = mono_domain_get ();
  main_args.143 = main_args;
  if (main_args.143 == 0B) goto <D.25697>; else goto <D.25698>;
  <D.25697>:
  D.25699 = 0B;
  return D.25699;
  <D.25698>:
  D.25700 = mono_defaults.string_class;
  num_main_args.144 = num_main_args;
  num_main_args.145 = (unsigned int) num_main_args.144;
  res = mono_array_new (domain, D.25700, num_main_args.145);
  i = 0;
  goto <D.22168>;
  <D.22167>:
  {
    void * * __p;

    i.146 = (unsigned int) i;
    __p = mono_array_addr_with_size (res, 4, i.146);
    main_args.143 = main_args;
    i.147 = (unsigned int) i;
    D.25705 = i.147 * 4;
    D.25706 = main_args.143 + D.25705;
    D.25707 = *D.25706;
    D.25708 = mono_string_new (domain, D.25707);
    mono_gc_wbarrier_set_arrayref (res, __p, D.25708);
  }
  i = i + 1;
  <D.22168>:
  num_main_args.144 = num_main_args;
  if (i < num_main_args.144) goto <D.22167>; else goto <D.22169>;
  <D.22169>:
  D.25699 = res;
  return D.25699;
}


mono_runtime_run_main (struct MonoMethod * method, int argc, char * * argv, struct MonoObject * * exc)
{
  _Bool D.25710;
  long int D.25711;
  long int D.25712;
  struct MonoThread * D.25715;
  unsigned int argc.148;
  unsigned int D.25717;
  void * main_args.149;
  char * D.25719;
  int D.25720;
  struct MonoClass * D.25723;
  struct MonoImage * D.25724;
  struct MonoAssembly * D.25725;
  char * D.25726;
  char * * main_args.150;
  unsigned int i.151;
  unsigned int D.25734;
  char * * D.25735;
  char * D.25736;
  char * * D.25739;
  short unsigned int D.25742;
  struct MonoClass * D.25745;
  unsigned int argc.152;
  unsigned int i.153;
  int D.25749;
  int i;
  struct MonoArray * args;
  struct MonoDomain * domain;
  gchar * utf8_fullpath;
  struct MonoMethodSignature * sig;

  args = 0B;
  domain = mono_domain_get ();
  D.25710 = method == 0B;
  D.25711 = (long int) D.25710;
  D.25712 = __builtin_expect (D.25711, 0);
  if (D.25712 != 0) goto <D.25713>; else goto <D.25714>;
  <D.25713>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 3601, "method != NULL");
  <D.25714>:
  D.25715 = mono_thread_current ();
  mono_thread_set_main (D.25715);
  argc.148 = (unsigned int) argc;
  D.25717 = argc.148 * 4;
  main_args.149 = monoeg_malloc0 (D.25717);
  main_args = main_args.149;
  num_main_args = argc;
  D.25719 = *argv;
  D.25720 = monoeg_g_path_is_absolute (D.25719);
  if (D.25720 == 0) goto <D.25721>; else goto <D.25722>;
  <D.25721>:
  {
    gchar * basename;
    gchar * fullpath;

    D.25719 = *argv;
    basename = monoeg_g_path_get_basename (D.25719);
    D.25723 = method->klass;
    D.25724 = D.25723->image;
    D.25725 = D.25724->assembly;
    D.25726 = D.25725->basedir;
    fullpath = monoeg_g_build_path ("/", D.25726, basename, 0B);
    utf8_fullpath = mono_utf8_from_external (fullpath);
    if (utf8_fullpath == 0B) goto <D.25727>; else goto <D.25728>;
    <D.25727>:
    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.25728>:
    monoeg_g_free (fullpath);
    monoeg_g_free (basename);
  }
  goto <D.25729>;
  <D.25722>:
  D.25719 = *argv;
  utf8_fullpath = mono_utf8_from_external (D.25719);
  if (utf8_fullpath == 0B) goto <D.25730>; else goto <D.25731>;
  <D.25730>:
  D.25719 = *argv;
  monoeg_g_print ("\nCannot determine the text encoding for the assembly location: %s\n", D.25719);
  monoeg_g_print ("Please add the correct encoding to MONO_EXTERNAL_ENCODINGS and try again.\n");
  exit (-1);
  <D.25731>:
  <D.25729>:
  main_args.150 = main_args;
  *main_args.150 = utf8_fullpath;
  i = 1;
  goto <D.22192>;
  <D.22191>:
  {
    gchar * utf8_arg;

    i.151 = (unsigned int) i;
    D.25734 = i.151 * 4;
    D.25735 = argv + D.25734;
    D.25736 = *D.25735;
    utf8_arg = mono_utf8_from_external (D.25736);
    if (utf8_arg == 0B) goto <D.25737>; else goto <D.25738>;
    <D.25737>:
    i.151 = (unsigned int) i;
    D.25734 = i.151 * 4;
    D.25735 = argv + D.25734;
    D.25736 = *D.25735;
    monoeg_g_print ("\nCannot determine the text encoding for argument %d (%s).\n", i, D.25736);
    monoeg_g_print ("Please add the correct encoding to MONO_EXTERNAL_ENCODINGS and try again.\n");
    exit (-1);
    <D.25738>:
    main_args.150 = main_args;
    i.151 = (unsigned int) i;
    D.25734 = i.151 * 4;
    D.25739 = main_args.150 + D.25734;
    *D.25739 = utf8_arg;
  }
  i = i + 1;
  <D.22192>:
  if (i < argc) goto <D.22191>; else goto <D.22193>;
  <D.22193>:
  argc = argc + -1;
  argv = argv + 4;
  sig = mono_method_signature (method);
  if (sig == 0B) goto <D.25740>; else goto <D.25741>;
  <D.25740>:
  monoeg_g_print ("Unable to load Main method.\n");
  exit (-1);
  <D.25741>:
  D.25742 = sig->param_count;
  if (D.25742 != 0) goto <D.25743>; else goto <D.25744>;
  <D.25743>:
  D.25745 = mono_defaults.string_class;
  argc.152 = (unsigned int) argc;
  args = mono_array_new (domain, D.25745, argc.152);
  i = 0;
  goto <D.22198>;
  <D.22197>:
  {
    gchar * str;
    struct MonoString * arg;

    i.151 = (unsigned int) i;
    D.25734 = i.151 * 4;
    D.25735 = argv + D.25734;
    D.25736 = *D.25735;
    str = mono_utf8_from_external (D.25736);
    arg = mono_string_new (domain, str);
    {
      void * * __p;

      i.153 = (unsigned int) i;
      __p = mono_array_addr_with_size (args, 4, i.153);
      mono_gc_wbarrier_set_arrayref (args, __p, arg);
    }
    monoeg_g_free (str);
  }
  i = i + 1;
  <D.22198>:
  if (i < argc) goto <D.22197>; else goto <D.22199>;
  <D.22199>:
  goto <D.25748>;
  <D.25744>:
  D.25745 = mono_defaults.string_class;
  args = mono_array_new (domain, D.25745, 0);
  <D.25748>:
  D.25723 = method->klass;
  D.25724 = D.25723->image;
  D.25725 = D.25724->assembly;
  mono_assembly_set_main (D.25725);
  D.25749 = mono_runtime_exec_main (method, args, exc);
  return D.25749;
}


mono_object_xdomain_representation (struct MonoObject * obj, struct MonoDomain * target_domain, struct MonoObject * * exc)
{
  struct MonoVTable * D.25751;
  struct MonoClass * D.25752;
  unsigned char D.25753;
  unsigned char D.25754;
  struct MonoDomain * D.25758;
  int failure.154;
  struct MonoObject * D.25764;
  struct MonoObject * deserialized;
  gboolean failure;

  try
    {
      deserialized = 0B;
      failure = 0;
      *exc = 0B;
      D.25751 = obj->vtable;
      D.25752 = D.25751->klass;
      D.25753 = BIT_FIELD_REF <*D.25752, 8, 176>;
      D.25754 = D.25753 & 64;
      if (D.25754 != 0) goto <D.25755>; else goto <D.25756>;
      <D.25755>:
      deserialized = make_transparent_proxy (obj, &failure, exc);
      goto <D.25757>;
      <D.25756>:
      {
        struct MonoDomain * domain;
        struct MonoObject * serialized;

        domain = mono_domain_get ();
        D.25751 = obj->vtable;
        D.25758 = D.25751->domain;
        mono_domain_set_internal_with_options (D.25758, 0);
        serialized = serialize_object (obj, &failure, exc);
        mono_domain_set_internal_with_options (target_domain, 0);
        failure.154 = failure;
        if (failure.154 == 0) goto <D.25760>; else goto <D.25761>;
        <D.25760>:
        deserialized = deserialize_object (serialized, &failure, exc);
        <D.25761>:
        if (domain != target_domain) goto <D.25762>; else goto <D.25763>;
        <D.25762>:
        mono_domain_set_internal_with_options (domain, 0);
        <D.25763>:
      }
      <D.25757>:
      D.25764 = deserialized;
      return D.25764;
    }
  finally
    {
      failure = {CLOBBER};
    }
}


make_transparent_proxy (struct MonoObject * obj, gboolean * failure, struct MonoObject * * exc)
{
  struct MonoMethod * get_proxy_method.155;
  struct MonoClass * D.25770;
  struct MonoMethod * get_proxy_method.156;
  struct MonoVTable * D.25772;
  struct MonoClass * D.25773;
  unsigned char D.25774;
  unsigned char D.25775;
  _Bool D.25776;
  long int D.25777;
  long int D.25778;
  struct MonoType * D.25781;
  struct MonoReflectionType * * D.25782;
  struct MonoObject * * D.25783;
  struct MonoObject * D.25784;
  struct MonoObject * D.25787;
  static struct MonoMethod * get_proxy_method;
  struct MonoDomain * domain;
  struct MonoRealProxy * real_proxy;
  struct MonoReflectionType * reflection_type;
  struct MonoTransparentProxy * transparent_proxy;

  domain = mono_domain_get ();
  get_proxy_method.155 = get_proxy_method;
  if (get_proxy_method.155 == 0B) goto <D.25768>; else goto <D.25769>;
  <D.25768>:
  D.25770 = mono_defaults.real_proxy_class;
  get_proxy_method.156 = mono_class_get_method_from_name (D.25770, "GetTransparentProxy", 0);
  get_proxy_method = get_proxy_method.156;
  <D.25769>:
  D.25772 = obj->vtable;
  D.25773 = D.25772->klass;
  D.25774 = BIT_FIELD_REF <*D.25773, 8, 176>;
  D.25775 = D.25774 & 64;
  D.25776 = D.25775 == 0;
  D.25777 = (long int) D.25776;
  D.25778 = __builtin_expect (D.25777, 0);
  if (D.25778 != 0) goto <D.25779>; else goto <D.25780>;
  <D.25779>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 3751, "mono_class_is_marshalbyref (obj->vtable->klass)");
  <D.25780>:
  D.25770 = mono_defaults.real_proxy_class;
  real_proxy = mono_object_new (domain, D.25770);
  D.25772 = obj->vtable;
  D.25773 = D.25772->klass;
  D.25781 = &D.25773->byval_arg;
  reflection_type = mono_type_get_object (domain, D.25781);
  D.25782 = &real_proxy->class_to_proxy;
  mono_gc_wbarrier_set_field (real_proxy, D.25782, reflection_type);
  D.25783 = &real_proxy->unwrapped_server;
  mono_gc_wbarrier_set_field (real_proxy, D.25783, obj);
  *exc = 0B;
  get_proxy_method.155 = get_proxy_method;
  transparent_proxy = mono_runtime_invoke (get_proxy_method.155, real_proxy, 0B, exc);
  D.25784 = *exc;
  if (D.25784 != 0B) goto <D.25785>; else goto <D.25786>;
  <D.25785>:
  *failure = 1;
  <D.25786>:
  D.25787 = transparent_proxy;
  return D.25787;
}


serialize_object (struct MonoObject * obj, gboolean * failure, struct MonoObject * * exc)
{
  struct MonoMethod * serialize_method.157;
  struct MonoImage * D.25792;
  struct MonoMethod * serialize_method.158;
  struct MonoObject * D.25796;
  struct MonoVTable * D.25797;
  struct MonoClass * D.25798;
  unsigned char D.25799;
  unsigned char D.25800;
  _Bool D.25801;
  long int D.25802;
  long int D.25803;
  struct MonoObject * D.25806;
  static struct MonoMethod * serialize_method;
  void * params[1];
  struct MonoObject * array;

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

        D.25792 = mono_defaults.corlib;
        klass = mono_class_from_name (D.25792, "System.Runtime.Remoting", "RemotingServices");
        serialize_method.158 = mono_class_get_method_from_name (klass, "SerializeCallData", -1);
        serialize_method = serialize_method.158;
      }
      <D.25791>:
      serialize_method.157 = serialize_method;
      if (serialize_method.157 == 0B) goto <D.25794>; else goto <D.25795>;
      <D.25794>:
      *failure = 1;
      D.25796 = 0B;
      return D.25796;
      <D.25795>:
      D.25797 = obj->vtable;
      D.25798 = D.25797->klass;
      D.25799 = BIT_FIELD_REF <*D.25798, 8, 176>;
      D.25800 = D.25799 & 64;
      D.25801 = D.25800 != 0;
      D.25802 = (long int) D.25801;
      D.25803 = __builtin_expect (D.25802, 0);
      if (D.25803 != 0) goto <D.25804>; else goto <D.25805>;
      <D.25804>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 3700, "!mono_class_is_marshalbyref (mono_object_class (obj))");
      <D.25805>:
      params[0] = obj;
      *exc = 0B;
      serialize_method.157 = serialize_method;
      array = mono_runtime_invoke (serialize_method.157, 0B, &params, exc);
      D.25806 = *exc;
      if (D.25806 != 0B) goto <D.25807>; else goto <D.25808>;
      <D.25807>:
      *failure = 1;
      <D.25808>:
      D.25796 = array;
      return D.25796;
    }
  finally
    {
      params = {CLOBBER};
    }
}


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

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

        D.25814 = mono_defaults.corlib;
        klass = mono_class_from_name (D.25814, "System.Runtime.Remoting", "RemotingServices");
        deserialize_method.160 = mono_class_get_method_from_name (klass, "DeserializeCallData", -1);
        deserialize_method = deserialize_method.160;
      }
      <D.25813>:
      deserialize_method.159 = deserialize_method;
      if (deserialize_method.159 == 0B) goto <D.25816>; else goto <D.25817>;
      <D.25816>:
      *failure = 1;
      D.25818 = 0B;
      return D.25818;
      <D.25817>:
      params[0] = obj;
      *exc = 0B;
      deserialize_method.159 = deserialize_method;
      result = mono_runtime_invoke (deserialize_method.159, 0B, &params, exc);
      D.25819 = *exc;
      if (D.25819 != 0B) goto <D.25820>; else goto <D.25821>;
      <D.25820>:
      *failure = 1;
      <D.25821>:
      D.25818 = result;
      return D.25818;
    }
  finally
    {
      params = {CLOBBER};
    }
}


mono_runtime_unhandled_exception_policy_set (MonoRuntimeUnhandledExceptionPolicy policy)
{
  runtime_unhandled_exception_policy = policy;
}


mono_runtime_unhandled_exception_policy_get ()
{
  MonoRuntimeUnhandledExceptionPolicy D.25824;

  D.25824 = runtime_unhandled_exception_policy;
  return D.25824;
}


mono_unhandled_exception (struct MonoObject * exc)
{
  struct MonoClass * D.25826;
  _Bool D.25827;
  long int D.25828;
  long int D.25829;
  struct MonoVTable * D.25832;
  struct MonoClass * D.25833;
  struct MonoClass * D.25834;
  int iftmp.161;
  struct MonoThread * main_thread.162;
  struct MonoInternalThread * D.25844;
  struct _MonoInternalThread * D.25845;
  <unnamed type> D.25846;
  struct MonoAppDomain * D.25847;
  int D.25848;
  sizetype D.25849;
  struct MonoObject * * D.25850;
  struct MonoAppDomain * D.25853;
  struct MonoObject * * D.25854;
  _Bool D.25856;
  _Bool D.25857;
  _Bool D.25858;
  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.25826 = mono_defaults.appdomain_class;
  field = mono_class_get_field_from_name (D.25826, "UnhandledException");
  D.25827 = field == 0B;
  D.25828 = (long int) D.25827;
  D.25829 = __builtin_expect (D.25828, 0);
  if (D.25829 != 0) goto <D.25830>; else goto <D.25831>;
  <D.25830>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 3940, "field");
  <D.25831>:
  D.25832 = exc->vtable;
  D.25833 = D.25832->klass;
  D.25834 = mono_defaults.threadabortexception_class;
  if (D.25833 != D.25834) goto <D.25835>; else goto <D.25836>;
  <D.25835>:
  {
    gboolean abort_process;

    main_thread.162 = main_thread;
    if (main_thread.162 != 0B) goto <D.25843>; else goto <D.25838>;
    <D.25843>:
    D.25844 = mono_thread_internal_current ();
    main_thread.162 = main_thread;
    D.25845 = main_thread.162->internal_thread;
    if (D.25844 == D.25845) goto <D.25839>; else goto <D.25838>;
    <D.25838>:
    D.25846 = mono_runtime_unhandled_exception_policy_get ();
    if (D.25846 == 1) goto <D.25839>; else goto <D.25840>;
    <D.25839>:
    iftmp.161 = 1;
    goto <D.25841>;
    <D.25840>:
    iftmp.161 = 0;
    <D.25841>:
    abort_process = iftmp.161;
    D.25847 = root_domain->domain;
    D.25848 = field->offset;
    D.25849 = (sizetype) D.25848;
    D.25850 = D.25847 + D.25849;
    root_appdomain_delegate = *D.25850;
    if (current_domain != root_domain) goto <D.25851>; else goto <D.25852>;
    <D.25851>:
    D.25853 = current_domain->domain;
    D.25848 = field->offset;
    D.25849 = (sizetype) D.25848;
    D.25854 = D.25853 + D.25849;
    current_appdomain_delegate = *D.25854;
    goto <D.25855>;
    <D.25852>:
    current_appdomain_delegate = 0B;
    <D.25855>:
    D.25856 = current_appdomain_delegate == 0B;
    D.25857 = root_appdomain_delegate == 0B;
    D.25858 = D.25856 & D.25857;
    if (D.25858 != 0) goto <D.25859>; else goto <D.25860>;
    <D.25859>:
    if (abort_process != 0) goto <D.25861>; else goto <D.25862>;
    <D.25861>:
    mono_environment_exitcode_set (1);
    <D.25862>:
    mono_print_unhandled_exception (exc);
    goto <D.25863>;
    <D.25860>:
    if (root_appdomain_delegate != 0B) goto <D.25864>; else goto <D.25865>;
    <D.25864>:
    call_unhandled_exception_delegate (root_domain, root_appdomain_delegate, exc);
    <D.25865>:
    if (current_appdomain_delegate != 0B) goto <D.25866>; else goto <D.25867>;
    <D.25866>:
    call_unhandled_exception_delegate (current_domain, current_appdomain_delegate, exc);
    <D.25867>:
    <D.25863>:
  }
  <D.25836>:
}


call_unhandled_exception_delegate (struct MonoDomain * domain, struct MonoObject * delegate, struct MonoObject * exc)
{
  struct MonoAppDomain * D.25870;
  struct MonoVTable * D.25871;
  struct MonoDomain * D.25872;
  _Bool D.25873;
  long int D.25874;
  long int D.25875;
  struct MonoVTable * D.25878;
  struct MonoDomain * D.25879;
  struct MonoObject * serialization_exc.163;
  _Bool D.25887;
  long int D.25888;
  long int D.25889;
  struct MonoImage * D.25893;
  _Bool D.25894;
  long int D.25895;
  long int D.25896;
  struct MonoObject * D.25899;
  struct MonoObject * e.164;
  struct MonoString * D.25905;
  int D.25906;
  struct MonoObject * e;
  void * pa[2];
  struct MonoDomain * current_domain;

  try
    {
      e = 0B;
      current_domain = mono_domain_get ();
      if (domain != current_domain) goto <D.25868>; else goto <D.25869>;
      <D.25868>:
      mono_domain_set_internal_with_options (domain, 0);
      <D.25869>:
      D.25870 = domain->domain;
      D.25871 = MEM[(struct MonoObject *)D.25870].vtable;
      D.25872 = D.25871->domain;
      D.25873 = D.25872 != domain;
      D.25874 = (long int) D.25873;
      D.25875 = __builtin_expect (D.25874, 0);
      if (D.25875 != 0) goto <D.25876>; else goto <D.25877>;
      <D.25876>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 3850, "domain == mono_object_domain (domain->domain)");
      <D.25877>:
      D.25878 = exc->vtable;
      D.25879 = D.25878->domain;
      if (D.25879 != domain) goto <D.25880>; else goto <D.25881>;
      <D.25880>:
      {
        struct MonoObject * serialization_exc;

        try
          {
            exc = mono_object_xdomain_representation (exc, domain, &serialization_exc);
            if (exc == 0B) goto <D.25882>; else goto <D.25883>;
            <D.25882>:
            serialization_exc.163 = serialization_exc;
            if (serialization_exc.163 != 0B) goto <D.25885>; else goto <D.25886>;
            <D.25885>:
            {
              struct MonoObject * dummy;

              try
                {
                  serialization_exc.163 = serialization_exc;
                  exc = mono_object_xdomain_representation (serialization_exc.163, domain, &dummy);
                  D.25887 = exc == 0B;
                  D.25888 = (long int) D.25887;
                  D.25889 = __builtin_expect (D.25888, 0);
                  if (D.25889 != 0) goto <D.25890>; else goto <D.25891>;
                  <D.25890>:
                  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 3860, "exc");
                  <D.25891>:
                }
              finally
                {
                  dummy = {CLOBBER};
                }
            }
            goto <D.25892>;
            <D.25886>:
            D.25893 = mono_get_corlib ();
            exc = mono_exception_from_name_msg (D.25893, "System.Runtime.Serialization", "SerializationException", "Could not serialize unhandled exception.");
            <D.25892>:
            <D.25883>:
          }
        finally
          {
            serialization_exc = {CLOBBER};
          }
      }
      <D.25881>:
      D.25878 = exc->vtable;
      D.25879 = D.25878->domain;
      D.25894 = D.25879 != domain;
      D.25895 = (long int) D.25894;
      D.25896 = __builtin_expect (D.25895, 0);
      if (D.25896 != 0) goto <D.25897>; else goto <D.25898>;
      <D.25897>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 3868, "mono_object_domain (exc) == domain");
      <D.25898>:
      D.25870 = domain->domain;
      pa[0] = D.25870;
      D.25899 = create_unhandled_exception_eventargs (exc);
      pa[1] = D.25899;
      mono_runtime_delegate_invoke (delegate, &pa, &e);
      if (domain != current_domain) goto <D.25900>; else goto <D.25901>;
      <D.25900>:
      mono_domain_set_internal_with_options (current_domain, 0);
      <D.25901>:
      e.164 = e;
      if (e.164 != 0B) goto <D.25903>; else goto <D.25904>;
      <D.25903>:
      {
        struct MonoError error;
        gchar * msg;

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


create_unhandled_exception_eventargs (struct MonoObject * exc)
{
  struct MonoImage * D.25910;
  _Bool D.25911;
  long int D.25912;
  long int D.25913;
  _Bool D.25916;
  long int D.25917;
  long int D.25918;
  struct MonoDomain * D.25921;
  struct MonoObject * D.25922;
  struct MonoClass * klass;
  void * args[2];
  struct MonoMethod * method;
  MonoBoolean is_terminating;
  struct MonoObject * obj;

  try
    {
      method = 0B;
      is_terminating = 1;
      D.25910 = mono_defaults.corlib;
      klass = mono_class_from_name (D.25910, "System", "UnhandledExceptionEventArgs");
      D.25911 = klass == 0B;
      D.25912 = (long int) D.25911;
      D.25913 = __builtin_expect (D.25912, 0);
      if (D.25913 != 0) goto <D.25914>; else goto <D.25915>;
      <D.25914>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 3823, "klass");
      <D.25915>:
      mono_class_init (klass);
      method = mono_class_get_method_from_name_flags (klass, ".ctor", 2, 6);
      D.25916 = method == 0B;
      D.25917 = (long int) D.25916;
      D.25918 = __builtin_expect (D.25917, 0);
      if (D.25918 != 0) goto <D.25919>; else goto <D.25920>;
      <D.25919>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 3829, "method");
      <D.25920>:
      args[0] = exc;
      args[1] = &is_terminating;
      D.25921 = mono_domain_get ();
      obj = mono_object_new (D.25921, klass);
      mono_runtime_invoke (method, obj, &args, 0B);
      D.25922 = obj;
      return D.25922;
    }
  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.25925;
  long int D.25926;
  long int D.25927;
  struct MonoVTable * D.25930;
  struct MonoAssembly * D.25931;
  struct MonoClass * D.25934;
  struct MonoImage * D.25935;
  struct MonoAppDomainSetup * D.25936;
  struct MonoString * D.25937;
  struct MonoString * * D.25940;
  char * D.25941;
  struct MonoString * D.25942;
  struct MonoString * D.25943;
  struct MonoImage * D.25946;
  char * D.25947;
  struct MonoString * * D.25948;
  struct MonoString * D.25949;
  struct MonoClass * stathread_attribute.165;
  struct MonoImage * D.25955;
  struct MonoClass * stathread_attribute.166;
  int D.25957;
  struct MonoMethodSignature * D.25964;
  struct MonoType * D.25965;
  unsigned char D.25966;
  struct MonoObject * D.25973;
  guint32 * D.25974;
  unsigned int D.25975;
  int D.25981;
  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.25925 = args == 0B;
      D.25926 = (long int) D.25925;
      D.25927 = __builtin_expect (D.25926, 0);
      if (D.25927 != 0) goto <D.25928>; else goto <D.25929>;
      <D.25928>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 4008, "args");
      <D.25929>:
      pa[0] = args;
      D.25930 = MEM[(struct MonoObject *)args].vtable;
      domain = D.25930->domain;
      D.25931 = domain->entry_assembly;
      if (D.25931 == 0B) goto <D.25932>; else goto <D.25933>;
      <D.25932>:
      {
        gchar * str;
        struct MonoAssembly * assembly;

        D.25934 = method->klass;
        D.25935 = D.25934->image;
        assembly = D.25935->assembly;
        domain->entry_assembly = assembly;
        D.25936 = domain->setup;
        D.25937 = D.25936->application_base;
        if (D.25937 == 0B) goto <D.25938>; else goto <D.25939>;
        <D.25938>:
        D.25936 = domain->setup;
        D.25936 = domain->setup;
        D.25940 = &D.25936->application_base;
        D.25941 = assembly->basedir;
        D.25942 = mono_string_new (domain, D.25941);
        mono_gc_wbarrier_set_field (D.25936, D.25940, D.25942);
        <D.25939>:
        D.25936 = domain->setup;
        D.25943 = D.25936->configuration_file;
        if (D.25943 == 0B) goto <D.25944>; else goto <D.25945>;
        <D.25944>:
        D.25946 = assembly->image;
        D.25947 = D.25946->name;
        str = monoeg_g_strconcat (D.25947, ".config", 0B);
        D.25936 = domain->setup;
        D.25936 = domain->setup;
        D.25948 = &D.25936->configuration_file;
        D.25949 = mono_string_new (domain, str);
        mono_gc_wbarrier_set_field (D.25936, D.25948, D.25949);
        monoeg_g_free (str);
        mono_set_private_bin_path_from_config (domain);
        <D.25945>:
      }
      <D.25933>:
      cinfo = mono_custom_attrs_from_method (method);
      if (cinfo != 0B) goto <D.25950>; else goto <D.25951>;
      <D.25950>:
      {
        static struct MonoClass * stathread_attribute = 0B;

        stathread_attribute.165 = stathread_attribute;
        if (stathread_attribute.165 == 0B) goto <D.25953>; else goto <D.25954>;
        <D.25953>:
        D.25955 = mono_defaults.corlib;
        stathread_attribute.166 = mono_class_from_name (D.25955, "System", "STAThreadAttribute");
        stathread_attribute = stathread_attribute.166;
        <D.25954>:
        stathread_attribute.165 = stathread_attribute;
        has_stathread_attribute = mono_custom_attrs_has_attr (cinfo, stathread_attribute.165);
        D.25957 = cinfo->cached;
        if (D.25957 == 0) goto <D.25958>; else goto <D.25959>;
        <D.25958>:
        mono_custom_attrs_free (cinfo);
        <D.25959>:
      }
      goto <D.25960>;
      <D.25951>:
      has_stathread_attribute = 0;
      <D.25960>:
      if (has_stathread_attribute != 0) goto <D.25961>; else goto <D.25962>;
      <D.25961>:
      thread->apartment_state = 0;
      goto <D.25963>;
      <D.25962>:
      thread->apartment_state = 1;
      <D.25963>:
      mono_thread_init_apartment_state ();
      D.25964 = mono_method_signature (method);
      D.25965 = D.25964->ret;
      D.25966 = D.25965->type;
      if (D.25966 == 8) goto <D.25967>; else goto <D.25968>;
      <D.25967>:
      {
        struct MonoObject * res;

        res = mono_runtime_invoke (method, 0B, &pa, exc);
        if (exc == 0B) goto <D.25969>; else goto <D.25972>;
        <D.25972>:
        D.25973 = *exc;
        if (D.25973 == 0B) goto <D.25969>; else goto <D.25970>;
        <D.25969>:
        D.25974 = res + 8;
        D.25975 = *D.25974;
        rval = (int) D.25975;
        goto <D.25971>;
        <D.25970>:
        rval = -1;
        <D.25971>:
        mono_environment_exitcode_set (rval);
      }
      goto <D.25976>;
      <D.25968>:
      mono_runtime_invoke (method, 0B, &pa, exc);
      if (exc == 0B) goto <D.25977>; else goto <D.25980>;
      <D.25980>:
      D.25973 = *exc;
      if (D.25973 == 0B) goto <D.25977>; else goto <D.25978>;
      <D.25977>:
      rval = 0;
      goto <D.25979>;
      <D.25978>:
      rval = -1;
      mono_environment_exitcode_set (rval);
      <D.25979>:
      <D.25976>:
      D.25981 = rval;
      return D.25981;
    }
  finally
    {
      pa = {CLOBBER};
    }
}


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

  if (func != 0B) goto <D.25985>; else goto <D.25986>;
  <D.25985>:
  iftmp.167 = func;
  goto <D.25987>;
  <D.25986>:
  iftmp.167 = dummy_mono_runtime_invoke;
  <D.25987>:
  default_mono_runtime_invoke = iftmp.167;
}


mono_runtime_invoke_array (struct MonoMethod * method, void * obj, struct MonoArray * params, struct MonoObject * * exc)
{
  unsigned int D.25990;
  unsigned int D.25991;
  unsigned char D.25992;
  int D.25993;
  struct MonoType * D.25997;
  struct MonoClass * D.25998;
  int D.25999;
  unsigned int i.168;
  unsigned int D.26002;
  void * * D.26003;
  unsigned int i.169;
  char * D.26005;
  struct MonoObject * D.26006;
  unsigned char D.26007;
  unsigned char D.26008;
  char * D.26011;
  struct MonoObject * D.26012;
  struct MonoDomain * D.26015;
  struct MonoClass * D.26016;
  struct MonoObject * D.26017;
  char * D.26020;
  struct MonoDomain * D.26021;
  struct MonoVTable * D.26022;
  struct MonoClass * D.26023;
  void * D.26024;
  char * D.26025;
  struct MonoObject * D.26026;
  void * D.26027;
  char * D.26030;
  char * D.26032;
  struct MonoObject * D.26033;
  struct MonoGenericClass * D.26036;
  struct MonoClass * D.26037;
  char * D.26039;
  struct MonoVTable * D.26043;
  struct MonoClass * D.26044;
  struct MonoClass * D.26045;
  _Bool D.26046;
  long int D.26047;
  long int D.26048;
  void * D.26051;
  unsigned char D.26052;
  int D.26053;
  unsigned int D.26054;
  int D.22350;
  int iftmp.170;
  int D.22349;
  const char[6] * D.26059;
  unsigned char D.26060;
  int D.26061;
  unsigned char D.26062;
  int D.26063;
  _Bool D.26064;
  _Bool D.26065;
  _Bool D.26066;
  const unsigned char * D.26069;
  unsigned char D.26070;
  int D.26071;
  const unsigned char * D.26072;
  unsigned char D.26073;
  int D.26074;
  _Bool D.26075;
  _Bool D.26076;
  const unsigned char * D.26079;
  unsigned char D.26080;
  int D.26081;
  const unsigned char * D.26082;
  unsigned char D.26083;
  int D.26084;
  _Bool D.26085;
  _Bool D.26086;
  const unsigned char * D.26089;
  unsigned char D.26090;
  int D.26091;
  const unsigned char * D.26092;
  unsigned char D.26093;
  int D.26094;
  const char * D.26096;
  struct MonoClass * D.26098;
  struct MonoClass * D.26099;
  int D.26101;
  _Bool D.26104;
  long int D.26105;
  long int D.26106;
  struct MonoObject * D.26111;
  struct MonoDomain * D.26112;
  struct MonoClass * D.26113;
  void * D.26114;
  struct MonoDomain * D.26117;
  _Bool D.26118;
  long int D.26119;
  long int D.26120;
  struct MonoVTable * D.26123;
  struct MonoClass * D.26124;
  struct MonoClass * D.26125;
  struct MonoMethod * iftmp.171;
  short int D.26129;
  struct MonoMethod * * D.26132;
  unsigned int D.26133;
  unsigned int D.26134;
  struct MonoMethod * * D.26135;
  unsigned char D.26137;
  unsigned char D.26138;
  struct MonoDomain * D.26145;
  int D.26146;
  struct MonoDomain * D.26149;
  void * D.26150;
  struct MonoDomain * D.26151;
  struct MonoObject * D.26152;
  struct MonoType * D.26153;
  unsigned char D.26154;
  struct MonoClass * pointer_class.174;
  struct MonoClass * tmp_klass.172;
  struct MonoImage * D.26162;
  struct MonoClass * tmp_klass.173;
  _Bool D.26164;
  long int D.26165;
  long int D.26166;
  struct MonoMethod * box_method.175;
  struct MonoMethod * box_method.176;
  struct MonoVTable * D.26173;
  struct MonoClass * D.26174;
  _Bool D.26175;
  long int D.26176;
  long int D.26177;
  void * D.26180;
  struct MonoDomain * D.26181;
  struct MonoReflectionType * D.26182;
  struct MonoObject * box_exc.177;
  _Bool D.26184;
  long int D.26185;
  long int D.26186;
  short unsigned int D.26191;
  short unsigned int D.26192;
  struct MonoClass * D.26195;
  int D.26196;
  void * D.26199;
  unsigned int D.26200;
  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.25988>; else goto <D.25989>;
  <D.25988>:
  D.25990 = mono_array_length (params);
  D.25991 = D.25990 * 4;
  pa = __builtin_alloca (D.25991);
  i = 0;
  goto <D.22340>;
  <D.22339>:
  {
    struct MonoType * t;

    t = sig->params[i];
    again:
    D.25992 = t->type;
    D.25993 = (int) D.25992;
    switch (D.25993) <default: <D.22337>, case 2: <D.22311>, case 3: <D.22314>, case 4: <D.22310>, case 5: <D.22309>, case 6: <D.22313>, case 7: <D.22312>, case 8: <D.22318>, case 9: <D.22317>, case 10: <D.22320>, case 11: <D.22319>, case 12: <D.22321>, case 13: <D.22322>, case 14: <D.22329>, case 15: <D.22335>, case 17: <D.22323>, case 18: <D.22331>, case 20: <D.22332>, case 21: <D.22334>, case 24: <D.22316>, case 25: <D.22315>, case 28: <D.22330>, case 29: <D.22333>>
    <D.22309>:
    <D.22310>:
    <D.22311>:
    <D.22312>:
    <D.22313>:
    <D.22314>:
    <D.22315>:
    <D.22316>:
    <D.22317>:
    <D.22318>:
    <D.22319>:
    <D.22320>:
    <D.22321>:
    <D.22322>:
    <D.22323>:
    D.25992 = t->type;
    if (D.25992 == 17) goto <D.25996>; else goto <D.25994>;
    <D.25996>:
    D.25997 = sig->params[i];
    D.25998 = mono_class_from_mono_type (D.25997);
    D.25999 = mono_class_is_nullable (D.25998);
    if (D.25999 != 0) goto <D.26000>; else goto <D.25994>;
    <D.26000>:
    i.168 = (unsigned int) i;
    D.26002 = i.168 * 4;
    D.26003 = pa + D.26002;
    i.169 = (unsigned int) i;
    D.26005 = mono_array_addr_with_size (params, 4, i.169);
    D.26006 = MEM[(struct MonoObject * *)D.26005];
    *D.26003 = D.26006;
    D.26007 = BIT_FIELD_REF <*t, 8, 56>;
    D.26008 = D.26007 & 64;
    if (D.26008 != 0) goto <D.26009>; else goto <D.26010>;
    <D.26009>:
    has_byref_nullables = 1;
    <D.26010>:
    goto <D.25995>;
    <D.25994>:
    i.169 = (unsigned int) i;
    D.26011 = mono_array_addr_with_size (params, 4, i.169);
    D.26012 = MEM[(struct MonoObject * *)D.26011];
    if (D.26012 == 0B) goto <D.26013>; else goto <D.26014>;
    <D.26013>:
    {
      void * * __p;

      i.169 = (unsigned int) i;
      __p = mono_array_addr_with_size (params, 4, i.169);
      D.26015 = mono_domain_get ();
      D.25997 = sig->params[i];
      D.26016 = mono_class_from_mono_type (D.25997);
      D.26017 = mono_object_new (D.26015, D.26016);
      mono_gc_wbarrier_set_arrayref (params, __p, D.26017);
    }
    <D.26014>:
    D.26007 = BIT_FIELD_REF <*t, 8, 56>;
    D.26008 = D.26007 & 64;
    if (D.26008 != 0) goto <D.26018>; else goto <D.26019>;
    <D.26018>:
    {
      struct MonoObject * orig;
      struct MonoObject * copy;

      i.169 = (unsigned int) i;
      D.26020 = mono_array_addr_with_size (params, 4, i.169);
      orig = MEM[(struct MonoObject * *)D.26020];
      D.26021 = mono_domain_get ();
      D.26022 = orig->vtable;
      D.26023 = D.26022->klass;
      D.26024 = mono_object_unbox (orig);
      copy = mono_value_box (D.26021, D.26023, D.26024);
      {
        void * * __p;

        i.169 = (unsigned int) i;
        __p = mono_array_addr_with_size (params, 4, i.169);
        mono_gc_wbarrier_set_arrayref (params, __p, copy);
      }
    }
    <D.26019>:
    i.168 = (unsigned int) i;
    D.26002 = i.168 * 4;
    D.26003 = pa + D.26002;
    i.169 = (unsigned int) i;
    D.26025 = mono_array_addr_with_size (params, 4, i.169);
    D.26026 = MEM[(struct MonoObject * *)D.26025];
    D.26027 = mono_object_unbox (D.26026);
    *D.26003 = D.26027;
    <D.25995>:
    goto <D.22328>;
    <D.22329>:
    <D.22330>:
    <D.22331>:
    <D.22332>:
    <D.22333>:
    D.26007 = BIT_FIELD_REF <*t, 8, 56>;
    D.26008 = D.26007 & 64;
    if (D.26008 != 0) goto <D.26028>; else goto <D.26029>;
    <D.26028>:
    i.168 = (unsigned int) i;
    D.26002 = i.168 * 4;
    D.26003 = pa + D.26002;
    i.169 = (unsigned int) i;
    D.26030 = mono_array_addr_with_size (params, 4, i.169);
    *D.26003 = D.26030;
    goto <D.26031>;
    <D.26029>:
    i.168 = (unsigned int) i;
    D.26002 = i.168 * 4;
    D.26003 = pa + D.26002;
    i.169 = (unsigned int) i;
    D.26032 = mono_array_addr_with_size (params, 4, i.169);
    D.26033 = MEM[(struct MonoObject * *)D.26032];
    *D.26003 = D.26033;
    <D.26031>:
    goto <D.22328>;
    <D.22334>:
    D.26007 = BIT_FIELD_REF <*t, 8, 56>;
    D.26008 = D.26007 & 64;
    if (D.26008 != 0) goto <D.26034>; else goto <D.26035>;
    <D.26034>:
    D.26036 = t->data.generic_class;
    D.26037 = D.26036->container_class;
    t = &D.26037->this_arg;
    goto <D.26038>;
    <D.26035>:
    D.26036 = t->data.generic_class;
    D.26037 = D.26036->container_class;
    t = &D.26037->byval_arg;
    <D.26038>:
    goto again;
    <D.22335>:
    {
      struct MonoObject * arg;

      i.169 = (unsigned int) i;
      D.26039 = mono_array_addr_with_size (params, 4, i.169);
      arg = MEM[(struct MonoObject * *)D.26039];
      if (arg == 0B) goto <D.26040>; else goto <D.26041>;
      <D.26040>:
      i.168 = (unsigned int) i;
      D.26002 = i.168 * 4;
      D.26003 = pa + D.26002;
      *D.26003 = 0B;
      goto <D.26042>;
      <D.26041>:
      D.26043 = arg->vtable;
      D.26044 = D.26043->klass;
      D.26045 = mono_defaults.int_class;
      D.26046 = D.26044 != D.26045;
      D.26047 = (long int) D.26046;
      D.26048 = __builtin_expect (D.26047, 0);
      if (D.26048 != 0) goto <D.26049>; else goto <D.26050>;
      <D.26049>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 4211, "arg->vtable->klass == mono_defaults.int_class");
      <D.26050>:
      i.168 = (unsigned int) i;
      D.26002 = i.168 * 4;
      D.26003 = pa + D.26002;
      D.26051 = MEM[(struct MonoIntPtr *)arg].m_value;
      *D.26003 = D.26051;
      <D.26042>:
      goto <D.22328>;
    }
    <D.22337>:
    D.25997 = sig->params[i];
    D.26052 = D.25997->type;
    D.26053 = (int) D.26052;
    monoeg_g_log (0B, 4, "type 0x%x not handled in mono_runtime_invoke_array", D.26053);
    <D.22338>:
    goto <D.22338>;
    <D.22328>:
  }
  i = i + 1;
  <D.22340>:
  i.169 = (unsigned int) i;
  D.26054 = mono_array_length (params);
  if (i.169 < D.26054) goto <D.22339>; else goto <D.22341>;
  <D.22341>:
  <D.25989>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = method->name;
      D.26059 = ".ctor";
      D.26060 = MEM[(const unsigned char *)D.26059];
      D.26061 = (int) D.26060;
      D.26062 = *__s2;
      D.26063 = (int) D.26062;
      __result = D.26061 - D.26063;
      {
        D.26064 = __s2_len != 0;
        D.26065 = __result == 0;
        D.26066 = D.26064 & D.26065;
        if (D.26066 != 0) goto <D.26067>; else goto <D.26068>;
        <D.26067>:
        D.26069 = &MEM[(void *)".ctor" + 1B];
        D.26070 = *D.26069;
        D.26071 = (int) D.26070;
        D.26072 = __s2 + 1;
        D.26073 = *D.26072;
        D.26074 = (int) D.26073;
        __result = D.26071 - D.26074;
        D.26075 = __s2_len > 1;
        D.26065 = __result == 0;
        D.26076 = D.26075 & D.26065;
        if (D.26076 != 0) goto <D.26077>; else goto <D.26078>;
        <D.26077>:
        D.26079 = &MEM[(void *)".ctor" + 2B];
        D.26080 = *D.26079;
        D.26081 = (int) D.26080;
        D.26082 = __s2 + 2;
        D.26083 = *D.26082;
        D.26084 = (int) D.26083;
        __result = D.26081 - D.26084;
        D.26085 = __s2_len > 2;
        D.26065 = __result == 0;
        D.26086 = D.26085 & D.26065;
        if (D.26086 != 0) goto <D.26087>; else goto <D.26088>;
        <D.26087>:
        D.26089 = &MEM[(void *)".ctor" + 3B];
        D.26090 = *D.26089;
        D.26091 = (int) D.26090;
        D.26092 = __s2 + 3;
        D.26093 = *D.26092;
        D.26094 = (int) D.26093;
        __result = D.26091 - D.26094;
        <D.26088>:
        <D.26078>:
        <D.26068>:
      }
      D.22349 = __result;
    }
    iftmp.170 = -D.22349;
    goto <D.26095>;
    <D.26058>:
    D.26096 = method->name;
    iftmp.170 = __builtin_strcmp (D.26096, ".ctor");
    <D.26095>:
    D.22350 = iftmp.170;
  }
  if (D.22350 == 0) goto <D.26097>; else goto <D.26055>;
  <D.26097>:
  D.26098 = method->klass;
  D.26099 = mono_defaults.string_class;
  if (D.26098 != D.26099) goto <D.26100>; else goto <D.26055>;
  <D.26100>:
  {
    void * o;

    o = obj;
    D.26098 = method->klass;
    D.26101 = mono_class_is_nullable (D.26098);
    if (D.26101 != 0) goto <D.26102>; else goto <D.26103>;
    <D.26102>:
    D.26104 = obj != 0B;
    D.26105 = (long int) D.26104;
    D.26106 = __builtin_expect (D.26105, 0);
    if (D.26106 != 0) goto <D.26107>; else goto <D.26108>;
    <D.26107>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 4227, "!obj");
    <D.26108>:
    if (params == 0B) goto <D.26109>; else goto <D.26110>;
    <D.26109>:
    D.26111 = 0B;
    return D.26111;
    <D.26110>:
    D.26112 = mono_domain_get ();
    D.26098 = method->klass;
    D.26113 = D.26098->cast_class;
    D.26114 = *pa;
    D.26111 = mono_value_box (D.26112, D.26113, D.26114);
    return D.26111;
    <D.26103>:
    if (obj == 0B) goto <D.26115>; else goto <D.26116>;
    <D.26115>:
    D.26117 = mono_domain_get ();
    D.26098 = method->klass;
    obj = mono_object_new (D.26117, D.26098);
    D.26118 = obj == 0B;
    D.26119 = (long int) D.26118;
    D.26120 = __builtin_expect (D.26119, 0);
    if (D.26120 != 0) goto <D.26121>; else goto <D.26122>;
    <D.26121>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 4237, "obj");
    <D.26122>:
    D.26123 = MEM[(struct MonoObject *)obj].vtable;
    D.26124 = D.26123->klass;
    D.26125 = mono_defaults.transparent_proxy_class;
    if (D.26124 == D.26125) goto <D.26126>; else goto <D.26127>;
    <D.26126>:
    D.26129 = method->slot;
    if (D.26129 != -1) goto <D.26130>; else goto <D.26131>;
    <D.26130>:
    D.26098 = method->klass;
    D.26132 = D.26098->vtable;
    D.26129 = method->slot;
    D.26133 = (unsigned int) D.26129;
    D.26134 = D.26133 * 4;
    D.26135 = D.26132 + D.26134;
    iftmp.171 = *D.26135;
    goto <D.26136>;
    <D.26131>:
    iftmp.171 = method;
    <D.26136>:
    method = mono_marshal_get_remoting_invoke (iftmp.171);
    <D.26127>:
    D.26098 = method->klass;
    D.26137 = BIT_FIELD_REF <*D.26098, 8, 160>;
    D.26138 = D.26137 & 8;
    if (D.26138 != 0) goto <D.26139>; else goto <D.26140>;
    <D.26139>:
    o = mono_object_unbox (obj);
    goto <D.26141>;
    <D.26140>:
    o = obj;
    <D.26141>:
    goto <D.26142>;
    <D.26116>:
    D.26098 = method->klass;
    D.26137 = BIT_FIELD_REF <*D.26098, 8, 160>;
    D.26138 = D.26137 & 8;
    if (D.26138 != 0) goto <D.26143>; else goto <D.26144>;
    <D.26143>:
    D.26145 = mono_domain_get ();
    D.26098 = method->klass;
    obj = mono_value_box (D.26145, D.26098, obj);
    <D.26144>:
    <D.26142>:
    mono_runtime_invoke (method, o, pa, exc);
    D.26111 = obj;
    return D.26111;
  }
  <D.26055>:
  D.26098 = method->klass;
  D.26146 = mono_class_is_nullable (D.26098);
  if (D.26146 != 0) goto <D.26147>; else goto <D.26148>;
  <D.26147>:
  {
    struct MonoObject * nullable;

    D.26149 = mono_domain_get ();
    D.26098 = method->klass;
    nullable = mono_object_new (D.26149, D.26098);
    D.26150 = mono_object_unbox (nullable);
    D.26151 = mono_domain_get ();
    D.26098 = method->klass;
    D.26113 = D.26098->cast_class;
    D.26152 = mono_value_box (D.26151, D.26113, obj);
    D.26098 = method->klass;
    mono_nullable_init (D.26150, D.26152, D.26098);
    obj = mono_object_unbox (nullable);
  }
  <D.26148>:
  res = mono_runtime_invoke (method, obj, pa, exc);
  D.26153 = sig->ret;
  D.26154 = D.26153->type;
  if (D.26154 == 15) goto <D.26155>; else goto <D.26156>;
  <D.26155>:
  {
    struct MonoClass * pointer_class;
    static struct MonoMethod * box_method;
    void * box_args[2];
    struct MonoObject * box_exc;

    try
      {
        {
          static struct MonoClass * tmp_klass;

          {
            tmp_klass.172 = tmp_klass;
            if (tmp_klass.172 == 0B) goto <D.26158>; else goto <D.26159>;
            <D.26158>:
            if (0 != 0) goto <D.26160>; else goto <D.26161>;
            <D.26160>:
            monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 4277, "mono_defaults.corlib == mono_defaults.corlib");
            <D.26161>:
            D.26162 = mono_defaults.corlib;
            tmp_klass.173 = mono_class_from_name (D.26162, "System.Reflection", "Pointer");
            tmp_klass = tmp_klass.173;
            tmp_klass.172 = tmp_klass;
            D.26164 = tmp_klass.172 == 0B;
            D.26165 = (long int) D.26164;
            D.26166 = __builtin_expect (D.26165, 0);
            if (D.26166 != 0) goto <D.26167>; else goto <D.26168>;
            <D.26167>:
            monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 4277, "tmp_klass");
            <D.26168>:
            <D.26159>:
          }
          pointer_class.174 = tmp_klass;
        }
        pointer_class = pointer_class.174;
        box_method.175 = box_method;
        if (box_method.175 == 0B) goto <D.26170>; else goto <D.26171>;
        <D.26170>:
        box_method.176 = mono_class_get_method_from_name (pointer_class, "Box", -1);
        box_method = box_method.176;
        <D.26171>:
        D.26173 = res->vtable;
        D.26174 = D.26173->klass;
        D.26045 = mono_defaults.int_class;
        D.26175 = D.26174 != D.26045;
        D.26176 = (long int) D.26175;
        D.26177 = __builtin_expect (D.26176, 0);
        if (D.26177 != 0) goto <D.26178>; else goto <D.26179>;
        <D.26178>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 4281, "res->vtable->klass == mono_defaults.int_class");
        <D.26179>:
        D.26180 = MEM[(struct MonoIntPtr *)res].m_value;
        box_args[0] = D.26180;
        D.26181 = mono_domain_get ();
        D.26153 = sig->ret;
        D.26182 = mono_type_get_object (D.26181, D.26153);
        box_args[1] = D.26182;
        box_method.175 = box_method;
        res = mono_runtime_invoke (box_method.175, 0B, &box_args, &box_exc);
        box_exc.177 = box_exc;
        D.26184 = box_exc.177 != 0B;
        D.26185 = (long int) D.26184;
        D.26186 = __builtin_expect (D.26185, 0);
        if (D.26186 != 0) goto <D.26187>; else goto <D.26188>;
        <D.26187>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 4285, "!box_exc");
        <D.26188>:
      }
    finally
      {
        box_args = {CLOBBER};
        box_exc = {CLOBBER};
      }
  }
  <D.26156>:
  if (has_byref_nullables != 0) goto <D.26189>; else goto <D.26190>;
  <D.26189>:
  i = 0;
  goto <D.22362>;
  <D.22361>:
  {
    struct MonoType * t;

    t = sig->params[i];
    D.26191 = BIT_FIELD_REF <*t, 16, 48>;
    D.26192 = D.26191 & 16639;
    if (D.26192 == 16405) goto <D.26193>; else goto <D.26194>;
    <D.26193>:
    D.26195 = mono_class_from_mono_type (t);
    D.26196 = mono_class_is_nullable (D.26195);
    if (D.26196 != 0) goto <D.26197>; else goto <D.26198>;
    <D.26197>:
    {
      void * * __p;

      i.169 = (unsigned int) i;
      __p = mono_array_addr_with_size (params, 4, i.169);
      i.168 = (unsigned int) i;
      D.26002 = i.168 * 4;
      D.26003 = pa + D.26002;
      D.26199 = *D.26003;
      mono_gc_wbarrier_set_arrayref (params, __p, D.26199);
    }
    <D.26198>:
    <D.26194>:
  }
  i = i + 1;
  <D.22362>:
  i.169 = (unsigned int) i;
  D.26200 = mono_array_length (params);
  if (i.169 < D.26200) goto <D.22361>; else goto <D.22363>;
  <D.22363>:
  <D.26190>:
  D.26111 = res;
  return D.26111;
}


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

  vtable = mono_class_vtable (domain, klass);
  if (vtable == 0B) goto <D.26202>; else goto <D.26203>;
  <D.26202>:
  D.26204 = 0B;
  return D.26204;
  <D.26203>:
  D.26204 = mono_object_new_specific (vtable);
  return D.26204;
}


mono_object_new_pinned (struct MonoDomain * domain, struct MonoClass * klass)
{
  struct MonoObject * D.26208;
  int D.26209;
  unsigned int D.26210;
  struct MonoVTable * vtable;

  vtable = mono_class_vtable (domain, klass);
  if (vtable == 0B) goto <D.26206>; else goto <D.26207>;
  <D.26206>:
  D.26208 = 0B;
  return D.26208;
  <D.26207>:
  D.26209 = mono_class_instance_size (klass);
  D.26210 = (unsigned int) D.26209;
  D.26208 = mono_gc_alloc_pinned_obj (vtable, D.26210);
  return D.26208;
}


mono_object_new_specific (struct MonoVTable * vtable)
{
  unsigned char D.26214;
  unsigned char D.26215;
  struct MonoClass * D.26217;
  unsigned char D.26218;
  unsigned char D.26219;
  struct MonoDomain * D.26220;
  struct MonoImage * D.26223;
  unsigned char D.26224;
  unsigned char D.26225;
  _Bool D.26228;
  long int D.26229;
  long int D.26230;
  struct MonoDomain * D.26233;
  struct MonoType * D.26234;
  struct MonoReflectionType * D.26235;
  struct MonoObject * D.26238;
  struct MonoObject * o;

  D.26214 = BIT_FIELD_REF <*vtable, 8, 184>;
  D.26215 = D.26214 & 1;
  if (D.26215 != 0) goto <D.26212>; else goto <D.26216>;
  <D.26216>:
  D.26217 = vtable->klass;
  D.26218 = BIT_FIELD_REF <*D.26217, 8, 184>;
  D.26219 = D.26218 & 64;
  if (D.26219 != 0) goto <D.26212>; else goto <D.26213>;
  <D.26212>:
  {
    void * pa[1];
    struct MonoMethod * im;

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

          D.26223 = mono_defaults.corlib;
          klass = mono_class_from_name (D.26223, "System.Runtime.Remoting.Activation", "ActivationServices");
          D.26224 = BIT_FIELD_REF <*klass, 8, 160>;
          D.26225 = D.26224 & 1;
          if (D.26225 == 0) goto <D.26226>; else goto <D.26227>;
          <D.26226>:
          mono_class_init (klass);
          <D.26227>:
          im = mono_class_get_method_from_name (klass, "CreateProxyForType", 1);
          D.26228 = im == 0B;
          D.26229 = (long int) D.26228;
          D.26230 = __builtin_expect (D.26229, 0);
          if (D.26230 != 0) goto <D.26231>; else goto <D.26232>;
          <D.26231>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 4430, "im");
          <D.26232>:
          D.26220 = vtable->domain;
          D.26220->create_proxy_for_type_method = im;
        }
        <D.26222>:
        D.26233 = mono_domain_get ();
        D.26217 = vtable->klass;
        D.26234 = &D.26217->byval_arg;
        D.26235 = mono_type_get_object (D.26233, D.26234);
        pa[0] = D.26235;
        o = mono_runtime_invoke (im, 0B, &pa, 0B);
        if (o != 0B) goto <D.26236>; else goto <D.26237>;
        <D.26236>:
        D.26238 = o;
        return D.26238;
        <D.26237>:
      }
    finally
      {
        pa = {CLOBBER};
      }
  }
  <D.26213>:
  D.26238 = mono_object_new_alloc_specific (vtable);
  return D.26238;
}


mono_object_new_alloc_specific (struct MonoVTable * vtable)
{
  struct MonoClass * D.26242;
  unsigned char D.26243;
  unsigned char D.26244;
  void * D.26248;
  int D.26251;
  unsigned int D.26252;
  unsigned char D.26254;
  unsigned char D.26255;
  _Bool D.26256;
  long int D.26257;
  long int D.26258;
  int profile_allocs.178;
  _Bool D.26262;
  long int D.26263;
  long int D.26264;
  struct MonoObject * D.26267;
  struct MonoObject * o;

  D.26242 = vtable->klass;
  D.26243 = BIT_FIELD_REF <*D.26242, 8, 184>;
  D.26244 = D.26243 & 8;
  if (D.26244 == 0) goto <D.26245>; else goto <D.26246>;
  <D.26245>:
  o = mono_object_new_ptrfree (vtable);
  goto <D.26247>;
  <D.26246>:
  D.26248 = vtable->gc_descr;
  if (D.26248 != 0B) goto <D.26249>; else goto <D.26250>;
  <D.26249>:
  D.26242 = vtable->klass;
  D.26251 = D.26242->instance_size;
  D.26252 = (unsigned int) D.26251;
  o = mono_object_allocate_spec (D.26252, vtable);
  goto <D.26253>;
  <D.26250>:
  D.26242 = vtable->klass;
  D.26251 = D.26242->instance_size;
  D.26252 = (unsigned int) D.26251;
  o = mono_object_allocate (D.26252, vtable);
  <D.26253>:
  <D.26247>:
  D.26242 = vtable->klass;
  D.26254 = BIT_FIELD_REF <*D.26242, 8, 176>;
  D.26255 = D.26254 & 32;
  D.26256 = D.26255 != 0;
  D.26257 = (long int) D.26256;
  D.26258 = __builtin_expect (D.26257, 0);
  if (D.26258 != 0) goto <D.26259>; else goto <D.26260>;
  <D.26259>:
  mono_object_register_finalizer (o);
  <D.26260>:
  profile_allocs.178 = profile_allocs;
  D.26262 = profile_allocs.178 != 0;
  D.26263 = (long int) D.26262;
  D.26264 = __builtin_expect (D.26263, 0);
  if (D.26264 != 0) goto <D.26265>; else goto <D.26266>;
  <D.26265>:
  D.26242 = vtable->klass;
  mono_profiler_allocation (o, D.26242);
  <D.26266>:
  D.26267 = o;
  return D.26267;
}


mono_object_allocate_spec (size_t size, struct MonoVTable * vtable)
{
  long long unsigned int D.26269;
  long long unsigned int D.26270;
  void * D.26271;
  void * o;

  o = mono_gc_alloc_obj (vtable, size);
  D.26269 = mono_stats.new_object_count;
  D.26270 = D.26269 + 1;
  mono_stats.new_object_count = D.26270;
  D.26271 = o;
  return D.26271;
}


mono_object_allocate (size_t size, struct MonoVTable * vtable)
{
  long long unsigned int D.26273;
  long long unsigned int D.26274;
  void * D.26275;
  struct MonoObject * o;

  D.26273 = mono_stats.new_object_count;
  D.26274 = D.26273 + 1;
  mono_stats.new_object_count = D.26274;
  o = mono_gc_alloc_obj (vtable, size);
  D.26275 = o;
  return D.26275;
}


mono_object_new_fast (struct MonoVTable * vtable)
{
  struct MonoClass * D.26277;
  int D.26278;
  unsigned int D.26279;
  struct MonoObject * D.26280;
  struct MonoObject * o;

  D.26277 = vtable->klass;
  D.26278 = D.26277->instance_size;
  D.26279 = (unsigned int) D.26278;
  o = mono_gc_alloc_obj (vtable, D.26279);
  D.26280 = o;
  return D.26280;
}


mono_class_get_allocation_ftn (struct MonoVTable * vtable, gboolean for_box, gboolean * pass_size_in_words)
{
  <unnamed type> D.26282;
  unsigned int D.26283;
  struct MonoClass * D.26288;
  int D.26289;
  unsigned char D.26291;
  unsigned char D.26292;
  <unnamed type> D.26294;
  unsigned int D.26295;
  void * D.26296;
  unsigned char D.26297;
  unsigned char D.26298;
  void * D.26303;

  *pass_size_in_words = 0;
  D.26282 = mono_profiler_get_events ();
  D.26283 = D.26282 & 128;
  if (D.26283 == 0) goto <D.26284>; else goto <D.26285>;
  <D.26284>:
  profile_allocs = 0;
  <D.26285>:
  D.26288 = vtable->klass;
  D.26289 = mono_class_has_finalizer (D.26288);
  if (D.26289 != 0) goto <D.26286>; else goto <D.26290>;
  <D.26290>:
  D.26288 = vtable->klass;
  D.26291 = BIT_FIELD_REF <*D.26288, 8, 176>;
  D.26292 = D.26291 & 64;
  if (D.26292 != 0) goto <D.26286>; else goto <D.26293>;
  <D.26293>:
  D.26294 = mono_profiler_get_events ();
  D.26295 = D.26294 & 128;
  if (D.26295 != 0) goto <D.26286>; else goto <D.26287>;
  <D.26286>:
  D.26296 = mono_object_new_specific;
  return D.26296;
  <D.26287>:
  D.26288 = vtable->klass;
  D.26297 = BIT_FIELD_REF <*D.26288, 8, 184>;
  D.26298 = D.26297 & 8;
  if (D.26298 == 0) goto <D.26299>; else goto <D.26300>;
  <D.26299>:
  if (for_box != 0) goto <D.26301>; else goto <D.26302>;
  <D.26301>:
  D.26296 = mono_object_new_ptrfree_box;
  return D.26296;
  <D.26302>:
  D.26296 = mono_object_new_ptrfree;
  return D.26296;
  <D.26300>:
  D.26303 = vtable->gc_descr;
  if (D.26303 != 0B) goto <D.26304>; else goto <D.26305>;
  <D.26304>:
  D.26296 = mono_object_new_fast;
  return D.26296;
  <D.26305>:
  D.26296 = mono_object_new_specific;
  return D.26296;
}


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

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


mono_object_clone (struct MonoObject * obj)
{
  struct MonoVTable * D.26309;
  struct MonoClass * D.26310;
  unsigned char D.26311;
  struct MonoObject * D.26314;
  unsigned int size.179;
  unsigned char D.26316;
  unsigned char D.26317;
  void * D.26321;
  const void * D.26322;
  unsigned int size.180;
  unsigned int D.26324;
  int profile_allocs.181;
  _Bool D.26326;
  long int D.26327;
  long int D.26328;
  unsigned char D.26331;
  unsigned char D.26332;
  struct MonoObject * o;
  int size;

  D.26309 = obj->vtable;
  D.26310 = D.26309->klass;
  size = D.26310->instance_size;
  D.26309 = obj->vtable;
  D.26310 = D.26309->klass;
  D.26311 = D.26310->rank;
  if (D.26311 != 0) goto <D.26312>; else goto <D.26313>;
  <D.26312>:
  D.26314 = mono_array_clone (obj);
  return D.26314;
  <D.26313>:
  size.179 = (unsigned int) size;
  D.26309 = obj->vtable;
  o = mono_object_allocate (size.179, D.26309);
  D.26309 = obj->vtable;
  D.26310 = D.26309->klass;
  D.26316 = BIT_FIELD_REF <*D.26310, 8, 184>;
  D.26317 = D.26316 & 8;
  if (D.26317 != 0) goto <D.26318>; else goto <D.26319>;
  <D.26318>:
  mono_gc_wbarrier_object_copy (o, obj);
  goto <D.26320>;
  <D.26319>:
  {
    int size;

    D.26309 = obj->vtable;
    D.26310 = D.26309->klass;
    size = D.26310->instance_size;
    D.26321 = o + 8;
    D.26322 = obj + 8;
    size.180 = (unsigned int) size;
    D.26324 = size.180 + 4294967288;
    mono_gc_memmove_atomic (D.26321, D.26322, D.26324);
  }
  <D.26320>:
  profile_allocs.181 = profile_allocs;
  D.26326 = profile_allocs.181 != 0;
  D.26327 = (long int) D.26326;
  D.26328 = __builtin_expect (D.26327, 0);
  if (D.26328 != 0) goto <D.26329>; else goto <D.26330>;
  <D.26329>:
  D.26309 = obj->vtable;
  D.26310 = D.26309->klass;
  mono_profiler_allocation (o, D.26310);
  <D.26330>:
  D.26309 = obj->vtable;
  D.26310 = D.26309->klass;
  D.26331 = BIT_FIELD_REF <*D.26310, 8, 176>;
  D.26332 = D.26331 & 32;
  if (D.26332 != 0) goto <D.26333>; else goto <D.26334>;
  <D.26333>:
  mono_object_register_finalizer (o);
  <D.26334>:
  D.26314 = o;
  return D.26314;
}


mono_array_full_copy (struct MonoArray * src, struct MonoArray * dest)
{
  struct MonoVTable * D.26336;
  struct MonoVTable * D.26337;
  struct MonoClass * D.26338;
  _Bool D.26339;
  long int D.26340;
  long int D.26341;
  unsigned int D.26344;
  _Bool D.26345;
  long int D.26346;
  long int D.26347;
  int D.26350;
  unsigned int D.26351;
  struct MonoClass * D.26352;
  unsigned char D.26353;
  unsigned char D.26354;
  unsigned char D.26357;
  unsigned char D.26358;
  double[0:] * D.26361;
  unsigned int D.26362;
  int D.26363;
  double[0:] * D.26365;
  unsigned int D.26367;
  int D.26368;
  uintptr_t size;
  struct MonoClass * klass;

  D.26336 = src->obj.vtable;
  klass = D.26336->klass;
  D.26337 = dest->obj.vtable;
  D.26338 = D.26337->klass;
  D.26339 = D.26338 != klass;
  D.26340 = (long int) D.26339;
  D.26341 = __builtin_expect (D.26340, 0);
  if (D.26341 != 0) goto <D.26342>; else goto <D.26343>;
  <D.26342>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 4619, "klass == dest->obj.vtable->klass");
  <D.26343>:
  size = mono_array_length (src);
  D.26344 = mono_array_length (dest);
  D.26345 = D.26344 != size;
  D.26346 = (long int) D.26345;
  D.26347 = __builtin_expect (D.26346, 0);
  if (D.26347 != 0) goto <D.26348>; else goto <D.26349>;
  <D.26348>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 4622, "size == mono_array_length (dest)");
  <D.26349>:
  D.26350 = mono_array_element_size (klass);
  D.26351 = (unsigned int) D.26350;
  size = D.26351 * size;
  D.26352 = klass->element_class;
  D.26353 = BIT_FIELD_REF <*D.26352, 8, 160>;
  D.26354 = D.26353 & 8;
  if (D.26354 != 0) goto <D.26355>; else goto <D.26356>;
  <D.26355>:
  D.26352 = klass->element_class;
  D.26357 = BIT_FIELD_REF <*D.26352, 8, 184>;
  D.26358 = D.26357 & 8;
  if (D.26358 != 0) goto <D.26359>; else goto <D.26360>;
  <D.26359>:
  D.26361 = &src->vector;
  D.26362 = mono_array_length (src);
  D.26363 = (int) D.26362;
  mono_value_copy_array (dest, 0, D.26361, D.26363);
  goto <D.26364>;
  <D.26360>:
  D.26365 = &dest->vector;
  D.26361 = &src->vector;
  mono_gc_memmove_atomic (D.26365, D.26361, size);
  <D.26364>:
  goto <D.26366>;
  <D.26356>:
  {
    void * * __p;
    void * * __s;

    __p = mono_array_addr_with_size (dest, 4, 0);
    __s = mono_array_addr_with_size (src, 4, 0);
    D.26367 = mono_array_length (src);
    D.26368 = (int) D.26367;
    mono_gc_wbarrier_arrayref_copy (__p, __s, D.26368);
  }
  <D.26366>:
}


mono_array_clone_in_domain (struct MonoDomain * domain, struct MonoArray * array)
{
  struct MonoVTable * D.26369;
  struct MonoArrayBounds * D.26370;
  unsigned int size.182;
  int D.26374;
  unsigned int D.26375;
  unsigned int size.183;
  unsigned int size.184;
  struct MonoClass * D.26378;
  unsigned char D.26379;
  unsigned char D.26380;
  unsigned char D.26383;
  unsigned char D.26384;
  double[0:] * D.26387;
  unsigned int D.26388;
  int D.26389;
  double[0:] * D.26391;
  unsigned int D.26393;
  int D.26394;
  struct MonoArray * D.26395;
  unsigned char D.26396;
  unsigned int D.26397;
  unsigned int D.26398;
  int D.26399;
  unsigned int size.185;
  unsigned int D.26401;
  uintptr_t * D.26402;
  unsigned int D.26403;
  struct MonoArrayBounds * D.26404;
  unsigned int D.26405;
  unsigned int size.186;
  unsigned int D.26407;
  unsigned int D.26408;
  unsigned int D.26409;
  uintptr_t * D.26410;
  int D.26411;
  unsigned int D.26412;
  unsigned int D.26413;
  intptr_t * D.26414;
  unsigned int D.26419;
  int D.26420;
  unsigned int D.26423;
  int D.26424;
  struct MonoArray * o;
  uintptr_t size;
  uintptr_t i;
  uintptr_t * sizes;
  struct MonoClass * klass;

  try
    {
      D.26369 = array->obj.vtable;
      klass = D.26369->klass;
      D.26370 = array->bounds;
      if (D.26370 == 0B) goto <D.26371>; else goto <D.26372>;
      <D.26371>:
      size.182 = mono_array_length (array);
      size = size.182;
      o = mono_array_new_full (domain, klass, &size, 0B);
      D.26374 = mono_array_element_size (klass);
      D.26375 = (unsigned int) D.26374;
      size.183 = size;
      size.184 = D.26375 * size.183;
      size = size.184;
      D.26378 = klass->element_class;
      D.26379 = BIT_FIELD_REF <*D.26378, 8, 160>;
      D.26380 = D.26379 & 8;
      if (D.26380 != 0) goto <D.26381>; else goto <D.26382>;
      <D.26381>:
      D.26378 = klass->element_class;
      D.26383 = BIT_FIELD_REF <*D.26378, 8, 184>;
      D.26384 = D.26383 & 8;
      if (D.26384 != 0) goto <D.26385>; else goto <D.26386>;
      <D.26385>:
      D.26387 = &array->vector;
      D.26388 = mono_array_length (array);
      D.26389 = (int) D.26388;
      mono_value_copy_array (o, 0, D.26387, D.26389);
      goto <D.26390>;
      <D.26386>:
      D.26391 = &o->vector;
      D.26387 = &array->vector;
      size.183 = size;
      mono_gc_memmove_atomic (D.26391, D.26387, size.183);
      <D.26390>:
      goto <D.26392>;
      <D.26382>:
      {
        void * * __p;
        void * * __s;

        __p = mono_array_addr_with_size (o, 4, 0);
        __s = mono_array_addr_with_size (array, 4, 0);
        D.26393 = mono_array_length (array);
        D.26394 = (int) D.26393;
        mono_gc_wbarrier_arrayref_copy (__p, __s, D.26394);
      }
      <D.26392>:
      D.26395 = o;
      return D.26395;
      <D.26372>:
      D.26396 = klass->rank;
      D.26397 = (unsigned int) D.26396;
      D.26398 = D.26397 * 8;
      sizes = __builtin_alloca (D.26398);
      D.26399 = mono_array_element_size (klass);
      size.185 = (unsigned int) D.26399;
      size = size.185;
      i = 0;
      goto <D.22452>;
      <D.22451>:
      D.26401 = i * 4;
      D.26402 = sizes + D.26401;
      D.26370 = array->bounds;
      D.26403 = i * 8;
      D.26404 = D.26370 + D.26403;
      D.26405 = D.26404->length;
      *D.26402 = D.26405;
      D.26370 = array->bounds;
      D.26403 = i * 8;
      D.26404 = D.26370 + D.26403;
      D.26405 = D.26404->length;
      size.183 = size;
      size.186 = D.26405 * size.183;
      size = size.186;
      D.26396 = klass->rank;
      D.26407 = (unsigned int) D.26396;
      D.26408 = D.26407 + i;
      D.26409 = D.26408 * 4;
      D.26410 = sizes + D.26409;
      D.26370 = array->bounds;
      D.26403 = i * 8;
      D.26404 = D.26370 + D.26403;
      D.26411 = D.26404->lower_bound;
      D.26412 = (unsigned int) D.26411;
      *D.26410 = D.26412;
      i = i + 1;
      <D.22452>:
      D.26396 = klass->rank;
      D.26407 = (unsigned int) D.26396;
      if (D.26407 > i) goto <D.22451>; else goto <D.22453>;
      <D.22453>:
      D.26396 = klass->rank;
      D.26397 = (unsigned int) D.26396;
      D.26413 = D.26397 * 4;
      D.26414 = sizes + D.26413;
      o = mono_array_new_full (domain, klass, sizes, D.26414);
      D.26378 = klass->element_class;
      D.26379 = BIT_FIELD_REF <*D.26378, 8, 160>;
      D.26380 = D.26379 & 8;
      if (D.26380 != 0) goto <D.26415>; else goto <D.26416>;
      <D.26415>:
      D.26378 = klass->element_class;
      D.26383 = BIT_FIELD_REF <*D.26378, 8, 184>;
      D.26384 = D.26383 & 8;
      if (D.26384 != 0) goto <D.26417>; else goto <D.26418>;
      <D.26417>:
      D.26387 = &array->vector;
      D.26419 = mono_array_length (array);
      D.26420 = (int) D.26419;
      mono_value_copy_array (o, 0, D.26387, D.26420);
      goto <D.26421>;
      <D.26418>:
      D.26391 = &o->vector;
      D.26387 = &array->vector;
      size.183 = size;
      mono_gc_memmove_atomic (D.26391, D.26387, size.183);
      <D.26421>:
      goto <D.26422>;
      <D.26416>:
      {
        void * * __p;
        void * * __s;

        __p = mono_array_addr_with_size (o, 4, 0);
        __s = mono_array_addr_with_size (array, 4, 0);
        D.26423 = mono_array_length (array);
        D.26424 = (int) D.26423;
        mono_gc_wbarrier_arrayref_copy (__p, __s, D.26424);
      }
      <D.26422>:
      D.26395 = o;
      return D.26395;
    }
  finally
    {
      size = {CLOBBER};
    }
}


mono_array_clone (struct MonoArray * array)
{
  struct MonoArray * D.26427;
  struct MonoVTable * D.26428;
  struct MonoDomain * D.26429;

  D.26428 = MEM[(struct MonoObject *)array].vtable;
  D.26429 = D.26428->domain;
  D.26427 = mono_array_clone_in_domain (D.26429, array);
  return D.26427;
}


mono_array_calc_byte_len (struct MonoClass * class, uintptr_t len, uintptr_t * res)
{
  int D.26431;
  int iftmp.187;
  _Bool D.26435;
  _Bool D.26436;
  _Bool D.26437;
  unsigned int D.26439;
  _Bool D.26441;
  long int D.26442;
  long int D.26443;
  gboolean D.26446;
  _Bool D.26447;
  long int D.26448;
  long int D.26449;
  uintptr_t byte_len;

  D.26431 = mono_array_element_size (class);
  byte_len = (uintptr_t) D.26431;
  D.26435 = byte_len != 0;
  D.26436 = len != 0;
  D.26437 = D.26435 & D.26436;
  if (D.26437 != 0) goto <D.26438>; else goto <D.26433>;
  <D.26438>:
  D.26439 = 4294967295 / byte_len;
  if (D.26439 < len) goto <D.26440>; else goto <D.26433>;
  <D.26440>:
  iftmp.187 = 1;
  goto <D.26434>;
  <D.26433>:
  iftmp.187 = 0;
  <D.26434>:
  D.26441 = iftmp.187 != 0;
  D.26442 = (long int) D.26441;
  D.26443 = __builtin_expect (D.26442, 0);
  if (D.26443 != 0) goto <D.26444>; else goto <D.26445>;
  <D.26444>:
  D.26446 = 0;
  return D.26446;
  <D.26445>:
  byte_len = byte_len * len;
  D.26447 = byte_len > 4294967279;
  D.26448 = (long int) D.26447;
  D.26449 = __builtin_expect (D.26448, 0);
  if (D.26449 != 0) goto <D.26450>; else goto <D.26451>;
  <D.26450>:
  D.26446 = 0;
  return D.26446;
  <D.26451>:
  byte_len = byte_len + 16;
  *res = byte_len;
  D.26446 = 1;
  return D.26446;
}


mono_array_new_full (struct MonoDomain * domain, struct MonoClass * array_class, uintptr_t * lengths, intptr_t * lower_bounds)
{
  unsigned char D.26453;
  unsigned char D.26454;
  unsigned char D.26459;
  unsigned char D.26461;
  int D.26464;
  signed int len.188;
  unsigned int D.26468;
  unsigned int i.189;
  unsigned int D.26470;
  uintptr_t * D.26471;
  unsigned int D.26472;
  signed int D.26473;
  int iftmp.190;
  unsigned int D.26481;
  _Bool D.26483;
  long int D.26484;
  long int D.26485;
  int D.26488;
  int D.26489;
  unsigned int byte_len.191;
  _Bool D.26495;
  long int D.26496;
  long int D.26497;
  unsigned int D.26500;
  unsigned int byte_len.192;
  unsigned int D.26502;
  _Bool D.26503;
  long int D.26504;
  long int D.26505;
  unsigned int byte_len.193;
  long long unsigned int D.26512;
  long long unsigned int D.26513;
  unsigned int D.26516;
  struct MonoArrayBounds * D.26517;
  intptr_t * D.26520;
  int D.26521;
  int profile_allocs.194;
  _Bool D.26523;
  long int D.26524;
  long int D.26525;
  struct MonoArray * D.26528;
  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.26453 = BIT_FIELD_REF <*array_class, 8, 160>;
      D.26454 = D.26453 & 1;
      if (D.26454 == 0) goto <D.26455>; else goto <D.26456>;
      <D.26455>:
      mono_class_init (array_class);
      <D.26456>:
      len = 1;
      D.26459 = array_class->rank;
      if (D.26459 == 1) goto <D.26460>; else goto <D.26457>;
      <D.26460>:
      D.26461 = array_class->byval_arg.type;
      if (D.26461 == 29) goto <D.26458>; else goto <D.26462>;
      <D.26462>:
      if (lower_bounds != 0B) goto <D.26463>; else goto <D.26457>;
      <D.26463>:
      D.26464 = *lower_bounds;
      if (D.26464 == 0) goto <D.26458>; else goto <D.26457>;
      <D.26458>:
      len = *lengths;
      len.188 = (signed int) len;
      if (len.188 < 0) goto <D.26466>; else goto <D.26467>;
      <D.26466>:
      arith_overflow ();
      <D.26467>:
      bounds_size = 0;
      goto <D.22481>;
      <D.26457>:
      D.26459 = array_class->rank;
      D.26468 = (unsigned int) D.26459;
      bounds_size = D.26468 * 8;
      i = 0;
      goto <D.22480>;
      <D.22479>:
      i.189 = (unsigned int) i;
      D.26470 = i.189 * 4;
      D.26471 = lengths + D.26470;
      D.26472 = *D.26471;
      D.26473 = (signed int) D.26472;
      if (D.26473 < 0) goto <D.26474>; else goto <D.26475>;
      <D.26474>:
      arith_overflow ();
      <D.26475>:
      if (len != 0) goto <D.26479>; else goto <D.26477>;
      <D.26479>:
      i.189 = (unsigned int) i;
      D.26470 = i.189 * 4;
      D.26471 = lengths + D.26470;
      D.26472 = *D.26471;
      if (D.26472 != 0) goto <D.26480>; else goto <D.26477>;
      <D.26480>:
      i.189 = (unsigned int) i;
      D.26470 = i.189 * 4;
      D.26471 = lengths + D.26470;
      D.26472 = *D.26471;
      D.26481 = 4294967295 / len;
      if (D.26472 > D.26481) goto <D.26482>; else goto <D.26477>;
      <D.26482>:
      iftmp.190 = 1;
      goto <D.26478>;
      <D.26477>:
      iftmp.190 = 0;
      <D.26478>:
      D.26483 = iftmp.190 != 0;
      D.26484 = (long int) D.26483;
      D.26485 = __builtin_expect (D.26484, 0);
      if (D.26485 != 0) goto <D.26486>; else goto <D.26487>;
      <D.26486>:
      mono_gc_out_of_memory (4294967295);
      <D.26487>:
      i.189 = (unsigned int) i;
      D.26470 = i.189 * 4;
      D.26471 = lengths + D.26470;
      D.26472 = *D.26471;
      len = D.26472 * len;
      i = i + 1;
      <D.22480>:
      D.26459 = array_class->rank;
      D.26488 = (int) D.26459;
      if (D.26488 > i) goto <D.22479>; else goto <D.22481>;
      <D.22481>:
      D.26489 = mono_array_calc_byte_len (array_class, len, &byte_len);
      if (D.26489 == 0) goto <D.26490>; else goto <D.26491>;
      <D.26490>:
      mono_gc_out_of_memory (4294967295);
      <D.26491>:
      if (bounds_size != 0) goto <D.26492>; else goto <D.26493>;
      <D.26492>:
      byte_len.191 = byte_len;
      D.26495 = byte_len.191 > 4294967292;
      D.26496 = (long int) D.26495;
      D.26497 = __builtin_expect (D.26496, 0);
      if (D.26497 != 0) goto <D.26498>; else goto <D.26499>;
      <D.26498>:
      mono_gc_out_of_memory (4294967295);
      <D.26499>:
      byte_len.191 = byte_len;
      D.26500 = byte_len.191 + 3;
      byte_len.192 = D.26500 & 4294967292;
      byte_len = byte_len.192;
      D.26502 = ~bounds_size;
      byte_len.191 = byte_len;
      D.26503 = D.26502 < byte_len.191;
      D.26504 = (long int) D.26503;
      D.26505 = __builtin_expect (D.26504, 0);
      if (D.26505 != 0) goto <D.26506>; else goto <D.26507>;
      <D.26506>:
      mono_gc_out_of_memory (4294967295);
      <D.26507>:
      byte_len.191 = byte_len;
      byte_len.193 = byte_len.191 + bounds_size;
      byte_len = byte_len.193;
      <D.26493>:
      vtable = mono_class_vtable_full (domain, array_class, 1);
      if (bounds_size != 0) goto <D.26509>; else goto <D.26510>;
      <D.26509>:
      byte_len.191 = byte_len;
      o = mono_gc_alloc_array (vtable, byte_len.191, len, bounds_size);
      goto <D.26511>;
      <D.26510>:
      byte_len.191 = byte_len;
      o = mono_gc_alloc_vector (vtable, byte_len.191, len);
      <D.26511>:
      array = o;
      D.26512 = mono_stats.new_object_count;
      D.26513 = D.26512 + 1;
      mono_stats.new_object_count = D.26513;
      bounds = array->bounds;
      if (bounds_size != 0) goto <D.26514>; else goto <D.26515>;
      <D.26514>:
      i = 0;
      goto <D.22483>;
      <D.22482>:
      i.189 = (unsigned int) i;
      D.26516 = i.189 * 8;
      D.26517 = bounds + D.26516;
      i.189 = (unsigned int) i;
      D.26470 = i.189 * 4;
      D.26471 = lengths + D.26470;
      D.26472 = *D.26471;
      D.26517->length = D.26472;
      if (lower_bounds != 0B) goto <D.26518>; else goto <D.26519>;
      <D.26518>:
      i.189 = (unsigned int) i;
      D.26516 = i.189 * 8;
      D.26517 = bounds + D.26516;
      i.189 = (unsigned int) i;
      D.26470 = i.189 * 4;
      D.26520 = lower_bounds + D.26470;
      D.26521 = *D.26520;
      D.26517->lower_bound = D.26521;
      <D.26519>:
      i = i + 1;
      <D.22483>:
      D.26459 = array_class->rank;
      D.26488 = (int) D.26459;
      if (D.26488 > i) goto <D.22482>; else goto <D.22484>;
      <D.22484>:
      <D.26515>:
      profile_allocs.194 = profile_allocs;
      D.26523 = profile_allocs.194 != 0;
      D.26524 = (long int) D.26523;
      D.26525 = __builtin_expect (D.26524, 0);
      if (D.26525 != 0) goto <D.26526>; else goto <D.26527>;
      <D.26526>:
      mono_profiler_allocation (o, array_class);
      <D.26527>:
      D.26528 = array;
      return D.26528;
    }
  finally
    {
      byte_len = {CLOBBER};
    }
}


arith_overflow ()
{
  struct MonoException * D.26531;

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


mono_array_new (struct MonoDomain * domain, struct MonoClass * eclass, uintptr_t n)
{
  _Bool D.26532;
  long int D.26533;
  long int D.26534;
  struct MonoArray * D.26537;
  struct MonoVTable * D.26538;
  struct MonoClass * ac;

  ac = mono_array_class_get (eclass, 1);
  D.26532 = ac == 0B;
  D.26533 = (long int) D.26532;
  D.26534 = __builtin_expect (D.26533, 0);
  if (D.26534 != 0) goto <D.26535>; else goto <D.26536>;
  <D.26535>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 4869, "ac");
  <D.26536>:
  D.26538 = mono_class_vtable_full (domain, ac, 1);
  D.26537 = mono_array_new_specific (D.26538, n);
  return D.26537;
}


mono_array_new_specific (struct MonoVTable * vtable, uintptr_t n)
{
  signed int n.195;
  _Bool D.26541;
  long int D.26542;
  long int D.26543;
  struct MonoArray * D.26546;
  struct MonoClass * D.26547;
  int D.26548;
  unsigned int byte_len.196;
  long long unsigned int D.26552;
  long long unsigned int D.26553;
  int profile_allocs.197;
  _Bool D.26555;
  long int D.26556;
  long int D.26557;
  struct MonoObject * o;
  struct MonoArray * ao;
  uintptr_t byte_len;

  try
    {
      n.195 = (signed int) n;
      D.26541 = n.195 < 0;
      D.26542 = (long int) D.26541;
      D.26543 = __builtin_expect (D.26542, 0);
      if (D.26543 != 0) goto <D.26544>; else goto <D.26545>;
      <D.26544>:
      arith_overflow ();
      D.26546 = 0B;
      return D.26546;
      <D.26545>:
      D.26547 = vtable->klass;
      D.26548 = mono_array_calc_byte_len (D.26547, n, &byte_len);
      if (D.26548 == 0) goto <D.26549>; else goto <D.26550>;
      <D.26549>:
      mono_gc_out_of_memory (4294967295);
      D.26546 = 0B;
      return D.26546;
      <D.26550>:
      byte_len.196 = byte_len;
      o = mono_gc_alloc_vector (vtable, byte_len.196, n);
      ao = o;
      D.26552 = mono_stats.new_object_count;
      D.26553 = D.26552 + 1;
      mono_stats.new_object_count = D.26553;
      profile_allocs.197 = profile_allocs;
      D.26555 = profile_allocs.197 != 0;
      D.26556 = (long int) D.26555;
      D.26557 = __builtin_expect (D.26556, 0);
      if (D.26557 != 0) goto <D.26558>; else goto <D.26559>;
      <D.26558>:
      D.26547 = vtable->klass;
      mono_profiler_allocation (o, D.26547);
      <D.26559>:
      D.26546 = ao;
      return D.26546;
    }
  finally
    {
      byte_len = {CLOBBER};
    }
}


mono_string_new_utf16 (struct MonoDomain * domain, const guint16 * text, gint32 len)
{
  _Bool D.26562;
  long int D.26563;
  long int D.26564;
  mono_unichar2 * D.26567;
  int D.26568;
  unsigned int D.26569;
  struct MonoString * D.26570;
  struct MonoString * s;

  s = mono_string_new_size (domain, len);
  D.26562 = s == 0B;
  D.26563 = (long int) D.26562;
  D.26564 = __builtin_expect (D.26563, 0);
  if (D.26564 != 0) goto <D.26565>; else goto <D.26566>;
  <D.26565>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 4941, "s != NULL");
  <D.26566>:
  D.26567 = mono_string_chars (s);
  D.26568 = len * 2;
  D.26569 = (unsigned int) D.26568;
  memcpy (D.26567, text, D.26569);
  D.26570 = s;
  return D.26570;
}


mono_string_new_size (struct MonoDomain * domain, gint32 len)
{
  int D.26572;
  int D.26573;
  unsigned int D.26574;
  unsigned int len.198;
  struct MonoClass * D.26578;
  _Bool D.26579;
  long int D.26580;
  long int D.26581;
  int profile_allocs.199;
  _Bool D.26585;
  long int D.26586;
  long int D.26587;
  struct MonoString * D.26590;
  struct MonoString * s;
  struct MonoVTable * vtable;
  size_t size;

  D.26572 = len + 1;
  D.26573 = D.26572 * 2;
  D.26574 = (unsigned int) D.26573;
  size = D.26574 + 12;
  len.198 = (unsigned int) len;
  if (len.198 > size) goto <D.26576>; else goto <D.26577>;
  <D.26576>:
  mono_gc_out_of_memory (4294967295);
  <D.26577>:
  D.26578 = mono_defaults.string_class;
  vtable = mono_class_vtable (domain, D.26578);
  D.26579 = vtable == 0B;
  D.26580 = (long int) D.26579;
  D.26581 = __builtin_expect (D.26580, 0);
  if (D.26581 != 0) goto <D.26582>; else goto <D.26583>;
  <D.26582>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 4967, "vtable");
  <D.26583>:
  s = mono_gc_alloc_string (vtable, size, len);
  profile_allocs.199 = profile_allocs;
  D.26585 = profile_allocs.199 != 0;
  D.26586 = (long int) D.26585;
  D.26587 = __builtin_expect (D.26586, 0);
  if (D.26587 != 0) goto <D.26588>; else goto <D.26589>;
  <D.26588>:
  D.26578 = mono_defaults.string_class;
  mono_profiler_allocation (s, D.26578);
  <D.26589>:
  D.26590 = s;
  return D.26590;
}


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

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


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

  try
    {
      error = 0B;
      o = 0B;
      D.26601 = strlen (text);
      l = (int) D.26601;
      ut = monoeg_g_utf8_to_utf16 (text, l, 0B, &items_written, &error);
      error.203 = error;
      if (error.203 == 0B) goto <D.26603>; else goto <D.26604>;
      <D.26603>:
      items_written.204 = items_written;
      o = mono_string_new_utf16 (domain, ut, items_written.204);
      goto <D.26606>;
      <D.26604>:
      error.203 = error;
      monoeg_g_error_free (error.203);
      <D.26606>:
      monoeg_g_free (ut);
      D.26607 = o;
      return D.26607;
    }
  finally
    {
      error = {CLOBBER};
      items_written = {CLOBBER};
    }
}


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

  domain = mono_domain_get ();
  if (text != 0B) goto <D.26610>; else goto <D.26611>;
  <D.26610>:
  D.26612 = mono_string_new (domain, text);
  return D.26612;
  <D.26611>:
  D.26612 = 0B;
  return D.26612;
}


mono_value_box (struct MonoDomain * domain, struct MonoClass * class, void * value)
{
  unsigned char D.26614;
  unsigned char D.26615;
  _Bool D.26616;
  long int D.26617;
  long int D.26618;
  int D.26621;
  struct MonoObject * D.26624;
  int profile_allocs.205;
  _Bool D.26628;
  long int D.26629;
  long int D.26630;
  unsigned int size.206;
  unsigned int D.26634;
  int D.26635;
  _Bool D.26636;
  long int D.26637;
  long int D.26638;
  void * D.26641;
  unsigned char D.26642;
  unsigned char D.26643;
  struct MonoObject * res;
  int size;
  struct MonoVTable * vtable;

  D.26614 = BIT_FIELD_REF <*class, 8, 160>;
  D.26615 = D.26614 & 8;
  D.26616 = D.26615 == 0;
  D.26617 = (long int) D.26616;
  D.26618 = __builtin_expect (D.26617, 0);
  if (D.26618 != 0) goto <D.26619>; else goto <D.26620>;
  <D.26619>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 5092, "class->valuetype");
  <D.26620>:
  D.26621 = mono_class_is_nullable (class);
  if (D.26621 != 0) goto <D.26622>; else goto <D.26623>;
  <D.26622>:
  D.26624 = mono_nullable_box (value, class);
  return D.26624;
  <D.26623>:
  vtable = mono_class_vtable (domain, class);
  if (vtable == 0B) goto <D.26625>; else goto <D.26626>;
  <D.26625>:
  D.26624 = 0B;
  return D.26624;
  <D.26626>:
  size = mono_class_instance_size (class);
  res = mono_object_new_alloc_specific (vtable);
  profile_allocs.205 = profile_allocs;
  D.26628 = profile_allocs.205 != 0;
  D.26629 = (long int) D.26628;
  D.26630 = __builtin_expect (D.26629, 0);
  if (D.26630 != 0) goto <D.26631>; else goto <D.26632>;
  <D.26631>:
  mono_profiler_allocation (res, class);
  <D.26632>:
  size.206 = (unsigned int) size;
  D.26634 = size.206 + 4294967288;
  size = (int) D.26634;
  D.26635 = mono_class_value_size (class, 0B);
  D.26636 = D.26635 != size;
  D.26637 = (long int) D.26636;
  D.26638 = __builtin_expect (D.26637, 0);
  if (D.26638 != 0) goto <D.26639>; else goto <D.26640>;
  <D.26639>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 5107, "size == mono_class_value_size (class, NULL)");
  <D.26640>:
  D.26641 = res + 8;
  mono_gc_wbarrier_value_copy (D.26641, value, 1, class);
  D.26642 = BIT_FIELD_REF <*class, 8, 176>;
  D.26643 = D.26642 & 32;
  if (D.26643 != 0) goto <D.26644>; else goto <D.26645>;
  <D.26644>:
  mono_object_register_finalizer (res);
  <D.26645>:
  D.26624 = res;
  return D.26624;
}


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.26647;
  struct MonoClass * D.26648;
  double[0:] * D.26649;
  int D.26650;
  sizetype D.26651;
  struct MonoVTable * D.26652;
  struct MonoClass * D.26653;
  struct MonoClass * D.26654;
  int D.26655;
  _Bool D.26656;
  long int D.26657;
  long int D.26658;
  int size;
  char * d;

  D.26647 = dest->obj.vtable;
  D.26648 = D.26647->klass;
  size = mono_array_element_size (D.26648);
  D.26649 = &dest->vector;
  D.26650 = size * dest_idx;
  D.26651 = (sizetype) D.26650;
  d = D.26649 + D.26651;
  D.26652 = MEM[(struct MonoObject *)dest].vtable;
  D.26653 = D.26652->klass;
  D.26654 = D.26653->element_class;
  D.26655 = mono_class_value_size (D.26654, 0B);
  D.26656 = D.26655 != size;
  D.26657 = (long int) D.26656;
  D.26658 = __builtin_expect (D.26657, 0);
  if (D.26658 != 0) goto <D.26659>; else goto <D.26660>;
  <D.26659>:
  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.26660>:
  D.26652 = MEM[(struct MonoObject *)dest].vtable;
  D.26653 = D.26652->klass;
  D.26654 = D.26653->element_class;
  mono_gc_wbarrier_value_copy (d, src, count, D.26654);
}


mono_object_get_domain (struct MonoObject * obj)
{
  struct MonoDomain * D.26661;
  struct MonoVTable * D.26662;

  D.26662 = obj->vtable;
  D.26661 = D.26662->domain;
  return D.26661;
}


mono_object_get_class (struct MonoObject * obj)
{
  struct MonoClass * D.26664;
  struct MonoVTable * D.26665;

  D.26665 = obj->vtable;
  D.26664 = D.26665->klass;
  return D.26664;
}


mono_object_get_size (struct MonoObject * o)
{
  struct MonoVTable * D.26667;
  struct MonoClass * D.26668;
  unsigned int D.26671;
  int D.26672;
  int D.26673;
  unsigned int D.26674;
  unsigned char D.26675;
  int D.26678;
  unsigned int D.26679;
  unsigned int D.26680;
  unsigned int D.26681;
  struct MonoArrayBounds * D.26682;
  unsigned int D.26685;
  unsigned int D.26686;
  int D.26687;
  struct MonoClass * klass;

  D.26667 = o->vtable;
  klass = D.26667->klass;
  D.26668 = mono_defaults.string_class;
  if (D.26668 == klass) goto <D.26669>; else goto <D.26670>;
  <D.26669>:
  D.26672 = mono_string_length (o);
  D.26673 = D.26672 * 2;
  D.26674 = (unsigned int) D.26673;
  D.26671 = D.26674 + 14;
  return D.26671;
  <D.26670>:
  D.26667 = o->vtable;
  D.26675 = D.26667->rank;
  if (D.26675 != 0) goto <D.26676>; else goto <D.26677>;
  <D.26676>:
  {
    struct MonoArray * array;
    size_t size;

    array = o;
    D.26678 = mono_array_element_size (klass);
    D.26679 = (unsigned int) D.26678;
    D.26680 = mono_array_length (array);
    D.26681 = D.26679 * D.26680;
    size = D.26681 + 16;
    D.26682 = array->bounds;
    if (D.26682 != 0B) goto <D.26683>; else goto <D.26684>;
    <D.26683>:
    size = size + 3;
    size = size & 4294967292;
    D.26667 = o->vtable;
    D.26675 = D.26667->rank;
    D.26685 = (unsigned int) D.26675;
    D.26686 = D.26685 * 8;
    size = D.26686 + size;
    <D.26684>:
    D.26671 = size;
    return D.26671;
  }
  <D.26677>:
  D.26687 = mono_class_instance_size (klass);
  D.26671 = (unsigned int) D.26687;
  return D.26671;
}


mono_object_unbox (struct MonoObject * obj)
{
  struct MonoVTable * D.26689;
  struct MonoClass * D.26690;
  unsigned char D.26691;
  unsigned char D.26692;
  _Bool D.26693;
  long int D.26694;
  long int D.26695;
  void * D.26698;

  D.26689 = obj->vtable;
  D.26690 = D.26689->klass;
  D.26691 = BIT_FIELD_REF <*D.26690, 8, 160>;
  D.26692 = D.26691 & 8;
  D.26693 = D.26692 == 0;
  D.26694 = (long int) D.26693;
  D.26695 = __builtin_expect (D.26694, 0);
  if (D.26695 != 0) goto <D.26696>; else goto <D.26697>;
  <D.26696>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 5233, "obj->vtable->klass->valuetype");
  <D.26697>:
  D.26698 = obj + 8;
  return D.26698;
}


mono_object_isinst (struct MonoObject * obj, struct MonoClass * klass)
{
  unsigned char D.26700;
  unsigned char D.26701;
  unsigned char D.26706;
  unsigned char D.26707;
  unsigned int D.26709;
  unsigned int D.26710;
  struct MonoObject * D.26711;
  struct MonoObject * iftmp.207;
  struct MonoVTable * D.26715;
  struct MonoClass * D.26716;
  int D.26717;

  D.26700 = BIT_FIELD_REF <*klass, 8, 160>;
  D.26701 = D.26700 & 1;
  if (D.26701 == 0) goto <D.26702>; else goto <D.26703>;
  <D.26702>:
  mono_class_init (klass);
  <D.26703>:
  D.26706 = BIT_FIELD_REF <*klass, 8, 176>;
  D.26707 = D.26706 & 64;
  if (D.26707 != 0) goto <D.26704>; else goto <D.26708>;
  <D.26708>:
  D.26709 = klass->flags;
  D.26710 = D.26709 & 32;
  if (D.26710 != 0) goto <D.26704>; else goto <D.26705>;
  <D.26704>:
  D.26711 = mono_object_isinst_mbyref (obj, klass);
  return D.26711;
  <D.26705>:
  if (obj == 0B) goto <D.26712>; else goto <D.26713>;
  <D.26712>:
  D.26711 = 0B;
  return D.26711;
  <D.26713>:
  D.26715 = obj->vtable;
  D.26716 = D.26715->klass;
  D.26717 = mono_class_is_assignable_from (klass, D.26716);
  if (D.26717 != 0) goto <D.26718>; else goto <D.26719>;
  <D.26718>:
  iftmp.207 = obj;
  goto <D.26720>;
  <D.26719>:
  iftmp.207 = 0B;
  <D.26720>:
  D.26711 = iftmp.207;
  return D.26711;
}


mono_object_isinst_mbyref (struct MonoObject * obj, struct MonoClass * klass)
{
  struct MonoObject * D.26724;
  unsigned int D.26725;
  unsigned int D.26726;
  short unsigned int D.26729;
  short unsigned int D.26730;
  guint8 * D.26733;
  short unsigned int D.26734;
  sizetype D.26735;
  guint8 * D.26736;
  unsigned char D.26737;
  int D.26738;
  int D.26739;
  int D.26740;
  int D.26741;
  int D.26742;
  int D.26745;
  struct MonoVTable * D.26748;
  struct MonoClass * D.26749;
  int D.26750;
  struct MonoClass * D.26754;
  struct MonoRemoteClass * D.26757;
  short unsigned int D.26758;
  short unsigned int D.26759;
  struct MonoClass * * D.26762;
  sizetype D.26763;
  sizetype D.26764;
  sizetype D.26765;
  struct MonoClass * * D.26766;
  struct MonoClass * D.26767;
  struct MonoClass * D.26770;
  unsigned char D.26773;
  _Bool D.26776;
  long int D.26777;
  long int D.26778;
  struct MonoType * D.26781;
  struct MonoReflectionType * D.26782;
  void * D.26783;
  unsigned char D.26784;
  struct MonoVTable * vt;

  if (obj == 0B) goto <D.26722>; else goto <D.26723>;
  <D.26722>:
  D.26724 = 0B;
  return D.26724;
  <D.26723>:
  vt = obj->vtable;
  D.26725 = klass->flags;
  D.26726 = D.26725 & 32;
  if (D.26726 != 0) goto <D.26727>; else goto <D.26728>;
  <D.26727>:
  D.26729 = klass->interface_id;
  D.26730 = vt->max_interface_id;
  if (D.26729 <= D.26730) goto <D.26731>; else goto <D.26732>;
  <D.26731>:
  D.26733 = vt->interface_bitmap;
  D.26729 = klass->interface_id;
  D.26734 = D.26729 >> 3;
  D.26735 = (sizetype) D.26734;
  D.26736 = D.26733 + D.26735;
  D.26737 = *D.26736;
  D.26738 = (int) D.26737;
  D.26729 = klass->interface_id;
  D.26739 = (int) D.26729;
  D.26740 = D.26739 & 7;
  D.26741 = D.26738 >> D.26740;
  D.26742 = D.26741 & 1;
  if (D.26742 != 0) goto <D.26743>; else goto <D.26744>;
  <D.26743>:
  D.26724 = obj;
  return D.26724;
  <D.26744>:
  <D.26732>:
  D.26745 = mono_class_has_variant_generic_params (klass);
  if (D.26745 != 0) goto <D.26746>; else goto <D.26747>;
  <D.26746>:
  D.26748 = obj->vtable;
  D.26749 = D.26748->klass;
  D.26750 = mono_class_is_assignable_from (klass, D.26749);
  if (D.26750 != 0) goto <D.26751>; else goto <D.26752>;
  <D.26751>:
  D.26724 = obj;
  return D.26724;
  <D.26752>:
  <D.26747>:
  goto <D.26753>;
  <D.26728>:
  {
    struct MonoClass * oklass;

    oklass = vt->klass;
    D.26754 = mono_defaults.transparent_proxy_class;
    if (D.26754 == oklass) goto <D.26755>; else goto <D.26756>;
    <D.26755>:
    D.26757 = MEM[(struct MonoTransparentProxy *)obj].remote_class;
    oklass = D.26757->proxy_class;
    <D.26756>:
    mono_class_setup_supertypes (klass);
    D.26758 = oklass->idepth;
    D.26759 = klass->idepth;
    if (D.26758 >= D.26759) goto <D.26760>; else goto <D.26761>;
    <D.26760>:
    D.26762 = oklass->supertypes;
    D.26759 = klass->idepth;
    D.26763 = (sizetype) D.26759;
    D.26764 = D.26763 + 1073741823;
    D.26765 = D.26764 * 4;
    D.26766 = D.26762 + D.26765;
    D.26767 = *D.26766;
    if (D.26767 == klass) goto <D.26768>; else goto <D.26769>;
    <D.26768>:
    D.26724 = obj;
    return D.26724;
    <D.26769>:
    <D.26761>:
  }
  <D.26753>:
  D.26770 = vt->klass;
  D.26754 = mono_defaults.transparent_proxy_class;
  if (D.26770 == D.26754) goto <D.26771>; else goto <D.26772>;
  <D.26771>:
  D.26773 = MEM[(struct MonoTransparentProxy *)obj].custom_type_info;
  if (D.26773 != 0) goto <D.26774>; else goto <D.26775>;
  <D.26774>:
  {
    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.26776 = im == 0B;
        D.26777 = (long int) D.26776;
        D.26778 = __builtin_expect (D.26777, 0);
        if (D.26778 != 0) goto <D.26779>; else goto <D.26780>;
        <D.26779>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 5298, "im");
        <D.26780>:
        D.26781 = &klass->byval_arg;
        D.26782 = mono_type_get_object (domain, D.26781);
        pa[0] = D.26782;
        pa[1] = obj;
        res = mono_runtime_invoke (im, rp, &pa, 0B);
        D.26783 = mono_object_unbox (res);
        D.26784 = MEM[(MonoBoolean *)D.26783];
        if (D.26784 != 0) goto <D.26785>; else goto <D.26786>;
        <D.26785>:
        mono_upgrade_remote_class (domain, obj, klass);
        D.26724 = obj;
        return D.26724;
        <D.26786>:
      }
    finally
      {
        pa = {CLOBBER};
      }
  }
  <D.26775>:
  <D.26772>:
  D.26724 = 0B;
  return D.26724;
}


mono_object_castclass_mbyref (struct MonoObject * obj, struct MonoClass * klass)
{
  struct MonoObject * D.26792;
  struct MonoObject * D.26793;
  struct MonoImage * D.26796;
  struct MonoException * D.26797;

  if (obj == 0B) goto <D.26790>; else goto <D.26791>;
  <D.26790>:
  D.26792 = 0B;
  return D.26792;
  <D.26791>:
  D.26793 = mono_object_isinst_mbyref (obj, klass);
  if (D.26793 != 0B) goto <D.26794>; else goto <D.26795>;
  <D.26794>:
  D.26792 = obj;
  return D.26792;
  <D.26795>:
  D.26796 = mono_defaults.corlib;
  D.26797 = mono_exception_from_name (D.26796, "System", "InvalidCastException");
  mono_raise_exception (D.26797);
  D.26792 = 0B;
  return D.26792;
}


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

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


mono_string_is_interned_lookup (struct MonoString * str, int insert)
{
  struct MonoVTable * D.26801;
  _Bool D.26804;
  long int D.26805;
  long int D.26806;
  _Bool D.26813;
  long int D.26814;
  long int D.26815;
  struct MonoString * D.26818;
  _Bool D.26825;
  long int D.26826;
  long int D.26827;
  struct MonoString * D.26830;
  _Bool D.26835;
  long int D.26836;
  long int D.26837;
  _Bool D.26842;
  long int D.26843;
  long int D.26844;
  struct MonoGHashTable * ldstr_table;
  struct MonoString * res;
  struct MonoDomain * domain;

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

    ret = pthread_mutex_lock (&ldstr_section.mutex);
    if (ret != 0) goto <D.26802>; else goto <D.26803>;
    <D.26802>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
    <D.26803>:
    D.26804 = ret != 0;
    D.26805 = (long int) D.26804;
    D.26806 = __builtin_expect (D.26805, 0);
    if (D.26806 != 0) goto <D.26807>; else goto <D.26808>;
    <D.26807>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 5378, "ret == 0");
    <D.26808>:
  }
  res = mono_g_hash_table_lookup (ldstr_table, str);
  if (res != 0B) goto <D.26809>; else goto <D.26810>;
  <D.26809>:
  {
    int ret;

    ret = pthread_mutex_unlock (&ldstr_section.mutex);
    if (ret != 0) goto <D.26811>; else goto <D.26812>;
    <D.26811>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.26812>:
    D.26813 = ret != 0;
    D.26814 = (long int) D.26813;
    D.26815 = __builtin_expect (D.26814, 0);
    if (D.26815 != 0) goto <D.26816>; else goto <D.26817>;
    <D.26816>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 5380, "ret == 0");
    <D.26817>:
  }
  D.26818 = res;
  return D.26818;
  <D.26810>:
  if (insert != 0) goto <D.26819>; else goto <D.26820>;
  <D.26819>:
  str = mono_string_get_pinned (str);
  if (str != 0B) goto <D.26821>; else goto <D.26822>;
  <D.26821>:
  mono_g_hash_table_insert (ldstr_table, str, str);
  <D.26822>:
  {
    int ret;

    ret = pthread_mutex_unlock (&ldstr_section.mutex);
    if (ret != 0) goto <D.26823>; else goto <D.26824>;
    <D.26823>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.26824>:
    D.26825 = ret != 0;
    D.26826 = (long int) D.26825;
    D.26827 = __builtin_expect (D.26826, 0);
    if (D.26827 != 0) goto <D.26828>; else goto <D.26829>;
    <D.26828>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 5387, "ret == 0");
    <D.26829>:
  }
  D.26818 = str;
  return D.26818;
  <D.26820>:
  {
    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.26830 = ldstr_info.res;
        if (D.26830 != 0B) goto <D.26831>; else goto <D.26832>;
        <D.26831>:
        mono_g_hash_table_insert (ldstr_table, str, str);
        {
          int ret;

          ret = pthread_mutex_unlock (&ldstr_section.mutex);
          if (ret != 0) goto <D.26833>; else goto <D.26834>;
          <D.26833>:
          monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
          <D.26834>:
          D.26835 = ret != 0;
          D.26836 = (long int) D.26835;
          D.26837 = __builtin_expect (D.26836, 0);
          if (D.26837 != 0) goto <D.26838>; else goto <D.26839>;
          <D.26838>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 5402, "ret == 0");
          <D.26839>:
        }
        D.26818 = str;
        return D.26818;
        <D.26832>:
      }
    finally
      {
        ldstr_info = {CLOBBER};
      }
  }
  {
    int ret;

    ret = pthread_mutex_unlock (&ldstr_section.mutex);
    if (ret != 0) goto <D.26840>; else goto <D.26841>;
    <D.26840>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.26841>:
    D.26842 = ret != 0;
    D.26843 = (long int) D.26842;
    D.26844 = __builtin_expect (D.26843, 0);
    if (D.26844 != 0) goto <D.26845>; else goto <D.26846>;
    <D.26845>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 5406, "ret == 0");
    <D.26846>:
  }
  D.26818 = 0B;
  return D.26818;
}


str_lookup (struct MonoDomain * domain, void * user_data)
{
  struct MonoString * D.26852;
  struct MonoDomain * D.26854;
  struct MonoGHashTable * D.26855;
  struct MonoString * D.26856;
  void * D.26857;
  struct LDStrInfo * info;

  info = user_data;
  D.26852 = info->res;
  if (D.26852 != 0B) goto <D.26850>; else goto <D.26853>;
  <D.26853>:
  D.26854 = info->orig_domain;
  if (D.26854 == domain) goto <D.26850>; else goto <D.26851>;
  <D.26850>:
  return;
  <D.26851>:
  D.26855 = domain->ldstr_table;
  D.26856 = info->ins;
  D.26857 = mono_g_hash_table_lookup (D.26855, D.26856);
  info->res = D.26857;
}


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

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


mono_ldstr (struct MonoDomain * domain, struct MonoImage * image, guint32 idx)
{
  unsigned char D.26861;
  unsigned char D.26862;
  unsigned int D.26865;
  struct MonoString * D.26866;
  int D.26867;
  const char * D.26870;

  D.26861 = BIT_FIELD_REF <*image, 8, 128>;
  D.26862 = D.26861 & 8;
  if (D.26862 != 0) goto <D.26863>; else goto <D.26864>;
  <D.26863>:
  {
    struct MonoString * str;

    D.26865 = idx | 1879048192;
    str = mono_lookup_dynamic_token (image, D.26865, 0B);
    D.26866 = str;
    return D.26866;
  }
  <D.26864>:
  D.26867 = mono_verifier_verify_string_signature (image, idx, 0B);
  if (D.26867 == 0) goto <D.26868>; else goto <D.26869>;
  <D.26868>:
  D.26866 = 0B;
  return D.26866;
  <D.26869>:
  D.26870 = mono_metadata_user_string (image, idx);
  D.26866 = mono_ldstr_metadata_sig (domain, D.26870);
  return D.26866;
}


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

  try
    {
      result = mono_string_to_utf8_checked (s, &error);
      D.26872 = mono_error_ok (&error);
      if (D.26872 == 0) goto <D.26873>; else goto <D.26874>;
      <D.26873>:
      mono_error_raise_exception (&error);
      <D.26874>:
      D.26875 = result;
      return D.26875;
    }
  finally
    {
      error = {CLOBBER};
    }
}


mono_string_to_utf8_checked (struct MonoString * s, struct MonoError * error)
{
  char * D.26880;
  int D.26881;
  mono_unichar2 * D.26884;
  struct GError * gerror.208;
  gchar * D.26888;
  long int written.209;
  unsigned int D.26892;
  unsigned int written.210;
  long int written;
  char * as;
  struct GError * gerror;

  try
    {
      written = 0;
      gerror = 0B;
      mono_error_init (error);
      if (s == 0B) goto <D.26878>; else goto <D.26879>;
      <D.26878>:
      D.26880 = 0B;
      return D.26880;
      <D.26879>:
      D.26881 = s->length;
      if (D.26881 == 0) goto <D.26882>; else goto <D.26883>;
      <D.26882>:
      D.26880 = monoeg_strdup ("");
      return D.26880;
      <D.26883>:
      D.26884 = mono_string_chars (s);
      D.26881 = s->length;
      as = monoeg_g_utf16_to_utf8 (D.26884, D.26881, 0B, &written, &gerror);
      gerror.208 = gerror;
      if (gerror.208 != 0B) goto <D.26886>; else goto <D.26887>;
      <D.26886>:
      gerror.208 = gerror;
      D.26888 = gerror.208->message;
      mono_error_set_argument (error, "string", "%s", D.26888);
      gerror.208 = gerror;
      monoeg_g_error_free (gerror.208);
      D.26880 = 0B;
      return D.26880;
      <D.26887>:
      D.26881 = s->length;
      written.209 = written;
      if (D.26881 > written.209) goto <D.26890>; else goto <D.26891>;
      <D.26890>:
      {
        char * as2;

        D.26881 = s->length;
        D.26892 = (unsigned int) D.26881;
        as2 = monoeg_malloc0 (D.26892);
        written.209 = written;
        written.210 = (unsigned int) written.209;
        memcpy (as2, as, written.210);
        monoeg_g_free (as);
        as = as2;
      }
      <D.26891>:
      D.26880 = as;
      return D.26880;
    }
  finally
    {
      written = {CLOBBER};
      gerror = {CLOBBER};
    }
}


mono_string_to_utf8_ignore (struct MonoString * s)
{
  char * D.26898;
  int D.26899;
  mono_unichar2 * D.26902;
  long int written.211;
  unsigned int D.26906;
  unsigned int written.212;
  long int written;
  char * as;

  try
    {
      written = 0;
      if (s == 0B) goto <D.26896>; else goto <D.26897>;
      <D.26896>:
      D.26898 = 0B;
      return D.26898;
      <D.26897>:
      D.26899 = s->length;
      if (D.26899 == 0) goto <D.26900>; else goto <D.26901>;
      <D.26900>:
      D.26898 = monoeg_strdup ("");
      return D.26898;
      <D.26901>:
      D.26902 = mono_string_chars (s);
      D.26899 = s->length;
      as = monoeg_g_utf16_to_utf8 (D.26902, D.26899, 0B, &written, 0B);
      D.26899 = s->length;
      written.211 = written;
      if (D.26899 > written.211) goto <D.26904>; else goto <D.26905>;
      <D.26904>:
      {
        char * as2;

        D.26899 = s->length;
        D.26906 = (unsigned int) D.26899;
        as2 = monoeg_malloc0 (D.26906);
        written.211 = written;
        written.212 = (unsigned int) written.211;
        memcpy (as2, as, written.212);
        monoeg_g_free (as);
        as = as2;
      }
      <D.26905>:
      D.26898 = as;
      return D.26898;
    }
  finally
    {
      written = {CLOBBER};
    }
}


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

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


mono_string_to_utf8_internal (struct MonoMemPool * mp, struct MonoImage * image, struct MonoString * s, gboolean ignore_error, struct MonoError * error)
{
  int D.26915;
  char * D.26918;
  _Bool D.26919;
  _Bool D.26920;
  _Bool D.26921;
  unsigned int D.26924;
  unsigned int D.26925;
  unsigned int len.213;
  unsigned int len.214;
  unsigned int len.215;
  char * r;
  char * mp_s;
  int len;

  if (ignore_error != 0) goto <D.26912>; else goto <D.26913>;
  <D.26912>:
  r = mono_string_to_utf8_ignore (s);
  goto <D.26914>;
  <D.26913>:
  r = mono_string_to_utf8_checked (s, error);
  D.26915 = mono_error_ok (error);
  if (D.26915 == 0) goto <D.26916>; else goto <D.26917>;
  <D.26916>:
  D.26918 = 0B;
  return D.26918;
  <D.26917>:
  <D.26914>:
  D.26919 = mp == 0B;
  D.26920 = image == 0B;
  D.26921 = D.26919 & D.26920;
  if (D.26921 != 0) goto <D.26922>; else goto <D.26923>;
  <D.26922>:
  D.26918 = r;
  return D.26918;
  <D.26923>:
  D.26924 = strlen (r);
  D.26925 = D.26924 + 1;
  len = (int) D.26925;
  if (mp != 0B) goto <D.26926>; else goto <D.26927>;
  <D.26926>:
  len.213 = (unsigned int) len;
  mp_s = mono_mempool_alloc (mp, len.213);
  goto <D.26929>;
  <D.26927>:
  len.214 = (unsigned int) len;
  mp_s = mono_image_alloc (image, len.214);
  <D.26929>:
  len.215 = (unsigned int) len;
  memcpy (mp_s, r, len.215);
  monoeg_g_free (r);
  D.26918 = mp_s;
  return D.26918;
}


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

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


mono_string_to_utf16 (struct MonoString * s)
{
  mono_unichar2 * D.26937;
  int D.26938;
  int D.26939;
  int D.26940;
  unsigned int D.26941;
  int D.26942;
  sizetype D.26943;
  char * D.26944;
  sizetype D.26945;
  char * D.26946;
  mono_unichar2 * D.26949;
  unsigned int D.26950;
  char * as;

  if (s == 0B) goto <D.26935>; else goto <D.26936>;
  <D.26935>:
  D.26937 = 0B;
  return D.26937;
  <D.26936>:
  D.26938 = s->length;
  D.26939 = D.26938 + 1;
  D.26940 = D.26939 * 2;
  D.26941 = (unsigned int) D.26940;
  as = monoeg_malloc (D.26941);
  D.26938 = s->length;
  D.26942 = D.26938 * 2;
  D.26943 = (sizetype) D.26942;
  D.26944 = as + D.26943;
  *D.26944 = 0;
  D.26938 = s->length;
  D.26942 = D.26938 * 2;
  D.26943 = (sizetype) D.26942;
  D.26945 = D.26943 + 1;
  D.26946 = as + D.26945;
  *D.26946 = 0;
  D.26938 = s->length;
  if (D.26938 == 0) goto <D.26947>; else goto <D.26948>;
  <D.26947>:
  D.26937 = as;
  return D.26937;
  <D.26948>:
  D.26949 = mono_string_chars (s);
  D.26938 = s->length;
  D.26942 = D.26938 * 2;
  D.26950 = (unsigned int) D.26942;
  memcpy (as, D.26949, D.26950);
  D.26937 = as;
  return D.26937;
}


mono_string_from_utf16 (gunichar2 * data)
{
  struct MonoString * D.26954;
  unsigned int len.216;
  unsigned int D.26956;
  gunichar2 * D.26957;
  short unsigned int D.26958;
  struct MonoDomain * domain;
  int len;

  domain = mono_domain_get ();
  len = 0;
  if (data == 0B) goto <D.26952>; else goto <D.26953>;
  <D.26952>:
  D.26954 = 0B;
  return D.26954;
  <D.26953>:
  goto <D.22677>;
  <D.22676>:
  len = len + 1;
  <D.22677>:
  len.216 = (unsigned int) len;
  D.26956 = len.216 * 2;
  D.26957 = data + D.26956;
  D.26958 = *D.26957;
  if (D.26958 != 0) goto <D.22676>; else goto <D.22678>;
  <D.22678>:
  D.26954 = mono_string_new_utf16 (domain, data, len);
  return D.26954;
}


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

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


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

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


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


mono_get_eh_callbacks ()
{
  struct MonoRuntimeExceptionHandlingCallbacks * D.26964;

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


mono_raise_exception (struct MonoException * ex)
{
  void (*<T2f40>) (struct MonoException *) D.26966;

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


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

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


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

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


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

  f_os_handle.219 = f_os_handle;
  if (f_os_handle.219 == 0B) goto <D.26978>; else goto <D.26979>;
  <D.26978>:
  f_safe_handle.220 = f_safe_handle;
  if (f_safe_handle.220 == 0B) goto <D.26981>; else goto <D.26982>;
  <D.26981>:
  D.26983 = mono_defaults.manualresetevent_class;
  f_os_handle.221 = mono_class_get_field_from_name (D.26983, "os_handle");
  f_os_handle = f_os_handle.221;
  D.26983 = mono_defaults.manualresetevent_class;
  f_safe_handle.222 = mono_class_get_field_from_name (D.26983, "safe_wait_handle");
  f_safe_handle = f_safe_handle.222;
  <D.26982>:
  <D.26979>:
  f_os_handle.219 = f_os_handle;
  if (f_os_handle.219 != 0B) goto <D.26986>; else goto <D.26987>;
  <D.26986>:
  {
    void * retval;

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

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


mono_async_result_new (struct MonoDomain * domain, void * handle, struct MonoObject * state, void * data, struct MonoObject * object_data)
{
  struct MonoClass * D.26993;
  struct MonoObject * * D.26996;
  struct MonoObject * * D.26997;
  struct MonoObject * * D.26998;
  struct MonoObject * * D.27001;
  struct MonoWaitHandle * D.27002;
  struct MonoAsyncResult * D.27003;
  struct MonoAsyncResult * res;
  struct MonoObject * context;

  D.26993 = mono_defaults.asyncresult_class;
  res = mono_object_new (domain, D.26993);
  context = mono_runtime_capture_context (domain);
  if (context != 0B) goto <D.26994>; else goto <D.26995>;
  <D.26994>:
  D.26996 = &res->execution_context;
  mono_gc_wbarrier_set_field (res, D.26996, context);
  <D.26995>:
  res->data = data;
  D.26997 = &res->object_data;
  mono_gc_wbarrier_set_field (res, D.26997, object_data);
  D.26998 = &res->async_state;
  mono_gc_wbarrier_set_field (res, D.26998, state);
  if (handle != 0B) goto <D.26999>; else goto <D.27000>;
  <D.26999>:
  D.27001 = &res->handle;
  D.27002 = mono_wait_handle_new (domain, handle);
  mono_gc_wbarrier_set_field (res, D.27001, D.27002);
  <D.27000>:
  res->sync_completed = 0;
  res->completed = 0;
  D.27003 = res;
  return D.27003;
}


mono_runtime_capture_context (struct MonoDomain * domain)
{
  void * D.27007;
  void * D.27009;
  struct MonoObject * D.27012;
  void * D.27013;
  void * D.27014;
  struct MonoObject * (*RuntimeInvokeFunction) (struct MonoObject *, void * *, struct MonoObject * *, void *) runtime_invoke;

  D.27007 = domain->capture_context_runtime_invoke;
  if (D.27007 == 0B) goto <D.27005>; else goto <D.27008>;
  <D.27008>:
  D.27009 = domain->capture_context_method;
  if (D.27009 == 0B) goto <D.27005>; else goto <D.27006>;
  <D.27005>:
  {
    struct MonoMethod * method;
    struct MonoMethod * wrapper;

    method = mono_get_context_capture_method ();
    if (method == 0B) goto <D.27010>; else goto <D.27011>;
    <D.27010>:
    D.27012 = 0B;
    return D.27012;
    <D.27011>:
    wrapper = mono_marshal_get_runtime_invoke (method, 0);
    D.27013 = mono_compile_method (wrapper);
    domain->capture_context_runtime_invoke = D.27013;
    D.27014 = mono_compile_method (method);
    domain->capture_context_method = D.27014;
  }
  <D.27006>:
  D.27007 = domain->capture_context_runtime_invoke;
  runtime_invoke = (struct MonoObject * (*RuntimeInvokeFunction) (struct MonoObject *, void * *, struct MonoObject * *, void *)) D.27007;
  D.27009 = domain->capture_context_method;
  D.27012 = runtime_invoke (0B, 0B, 0B, D.27009);
  return D.27012;
}


mono_message_init (struct MonoDomain * domain, struct MonoMethodMessage * this, struct MonoReflectionMethod * method, struct MonoArray * out_args)
{
  struct MonoMethod * D.27016;
  struct MonoClass * object_array_klass.224;
  struct MonoClass * D.27020;
  _Bool D.27021;
  long int D.27022;
  long int D.27023;
  struct MonoClass * D.27026;
  struct MonoClass * D.27029;
  struct MonoReflectionMethod * * D.27032;
  struct MonoArray * * D.27033;
  struct MonoVTable * D.27034;
  short unsigned int D.27035;
  unsigned int D.27036;
  struct MonoArray * D.27037;
  struct MonoArray * * D.27038;
  struct MonoClass * byte_array_klass.225;
  struct MonoVTable * D.27040;
  struct MonoArray * D.27041;
  unsigned int D.27042;
  unsigned int D.27043;
  struct MonoArray * * D.27044;
  struct MonoClass * string_array_klass.226;
  struct MonoVTable * D.27046;
  struct MonoArray * D.27047;
  unsigned int i.227;
  unsigned int D.27049;
  char * * D.27050;
  char * D.27051;
  struct MonoArray * D.27052;
  unsigned int i.228;
  int D.27054;
  struct MonoType * D.27055;
  unsigned char D.27056;
  unsigned char D.27057;
  unsigned int j.229;
  char * D.27063;
  struct MonoArray * D.27064;
  short unsigned int D.27065;
  int D.27066;
  int D.27067;
  struct MonoArray * D.27073;
  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.27016 = method->method;
  sig = mono_method_signature (D.27016);
  object_array_klass.224 = object_array_klass;
  if (object_array_klass.224 == 0B) goto <D.27018>; else goto <D.27019>;
  <D.27018>:
  {
    struct MonoClass * klass;

    D.27020 = mono_defaults.byte_class;
    klass = mono_array_class_get (D.27020, 1);
    D.27021 = klass == 0B;
    D.27022 = (long int) D.27021;
    D.27023 = __builtin_expect (D.27022, 0);
    if (D.27023 != 0) goto <D.27024>; else goto <D.27025>;
    <D.27024>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 5891, "klass");
    <D.27025>:
    byte_array_klass = klass;
    D.27026 = mono_defaults.string_class;
    klass = mono_array_class_get (D.27026, 1);
    D.27021 = klass == 0B;
    D.27022 = (long int) D.27021;
    D.27023 = __builtin_expect (D.27022, 0);
    if (D.27023 != 0) goto <D.27027>; else goto <D.27028>;
    <D.27027>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 5895, "klass");
    <D.27028>:
    string_array_klass = klass;
    D.27029 = mono_defaults.object_class;
    klass = mono_array_class_get (D.27029, 1);
    D.27021 = klass == 0B;
    D.27022 = (long int) D.27021;
    D.27023 = __builtin_expect (D.27022, 0);
    if (D.27023 != 0) goto <D.27030>; else goto <D.27031>;
    <D.27030>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 5899, "klass");
    <D.27031>:
    mono_memory_barrier ();
    object_array_klass = klass;
  }
  <D.27019>:
  D.27032 = &this->method;
  mono_gc_wbarrier_set_field (this, D.27032, method);
  D.27033 = &this->args;
  object_array_klass.224 = object_array_klass;
  D.27034 = mono_class_vtable (domain, object_array_klass.224);
  D.27035 = sig->param_count;
  D.27036 = (unsigned int) D.27035;
  D.27037 = mono_array_new_specific (D.27034, D.27036);
  mono_gc_wbarrier_set_field (this, D.27033, D.27037);
  D.27038 = &this->arg_types;
  byte_array_klass.225 = byte_array_klass;
  D.27040 = mono_class_vtable (domain, byte_array_klass.225);
  D.27035 = sig->param_count;
  D.27036 = (unsigned int) D.27035;
  D.27041 = mono_array_new_specific (D.27040, D.27036);
  mono_gc_wbarrier_set_field (this, D.27038, D.27041);
  this->async_result = 0B;
  this->call_type = 0;
  D.27035 = sig->param_count;
  D.27042 = (unsigned int) D.27035;
  D.27043 = D.27042 * 4;
  names = monoeg_malloc (D.27043);
  D.27016 = method->method;
  mono_method_get_param_names (D.27016, names);
  D.27044 = &this->names;
  string_array_klass.226 = string_array_klass;
  D.27046 = mono_class_vtable (domain, string_array_klass.226);
  D.27035 = sig->param_count;
  D.27036 = (unsigned int) D.27035;
  D.27047 = mono_array_new_specific (D.27046, D.27036);
  mono_gc_wbarrier_set_field (this, D.27044, D.27047);
  i = 0;
  goto <D.22760>;
  <D.22759>:
  i.227 = (unsigned int) i;
  D.27049 = i.227 * 4;
  D.27050 = names + D.27049;
  D.27051 = *D.27050;
  name = mono_string_new (domain, D.27051);
  {
    void * * __p;

    D.27052 = this->names;
    i.228 = (unsigned int) i;
    __p = mono_array_addr_with_size (D.27052, 4, i.228);
    D.27052 = this->names;
    mono_gc_wbarrier_set_arrayref (D.27052, __p, name);
  }
  i = i + 1;
  <D.22760>:
  D.27035 = sig->param_count;
  D.27054 = (int) D.27035;
  if (D.27054 > i) goto <D.22759>; else goto <D.22761>;
  <D.22761>:
  monoeg_g_free (names);
  i = 0;
  j = 0;
  goto <D.22766>;
  <D.22765>:
  D.27055 = sig->params[i];
  D.27056 = BIT_FIELD_REF <*D.27055, 8, 56>;
  D.27057 = D.27056 & 64;
  if (D.27057 != 0) goto <D.27058>; else goto <D.27059>;
  <D.27058>:
  if (out_args != 0B) goto <D.27060>; else goto <D.27061>;
  <D.27060>:
  {
    struct MonoObject * arg;

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

      D.27064 = this->args;
      i.228 = (unsigned int) i;
      __p = mono_array_addr_with_size (D.27064, 4, i.228);
      D.27064 = this->args;
      mono_gc_wbarrier_set_arrayref (D.27064, __p, arg);
    }
    j = j + 1;
  }
  <D.27061>:
  arg_type = 2;
  D.27055 = sig->params[i];
  D.27065 = D.27055->attrs;
  D.27066 = (int) D.27065;
  D.27067 = D.27066 & 2;
  if (D.27067 == 0) goto <D.27068>; else goto <D.27069>;
  <D.27068>:
  arg_type = arg_type | 1;
  <D.27069>:
  goto <D.27070>;
  <D.27059>:
  arg_type = 1;
  D.27055 = sig->params[i];
  D.27065 = D.27055->attrs;
  D.27066 = (int) D.27065;
  D.27067 = D.27066 & 2;
  if (D.27067 != 0) goto <D.27071>; else goto <D.27072>;
  <D.27071>:
  arg_type = arg_type | 4;
  <D.27072>:
  <D.27070>:
  {
    guint8 * __p;

    D.27073 = this->arg_types;
    i.228 = (unsigned int) i;
    __p = mono_array_addr_with_size (D.27073, 1, i.228);
    *__p = arg_type;
  }
  i = i + 1;
  <D.22766>:
  D.27035 = sig->param_count;
  D.27054 = (int) D.27035;
  if (D.27054 > i) goto <D.22765>; else goto <D.22767>;
  <D.22767>:
}


mono_remoting_invoke (struct MonoObject * real_proxy, struct MonoMethodMessage * msg, struct MonoObject * * exc, struct MonoArray * * out_args)
{
  struct MonoVTable * D.27074;
  struct MonoDomain * D.27075;
  struct MonoClass * D.27078;
  _Bool D.27079;
  long int D.27080;
  long int D.27081;
  struct MonoObject * D.27084;
  struct MonoMethod * im;
  void * pa[4];

  try
    {
      D.27074 = real_proxy->vtable;
      D.27075 = D.27074->domain;
      im = D.27075->private_invoke_method;
      if (im == 0B) goto <D.27076>; else goto <D.27077>;
      <D.27076>:
      D.27078 = mono_defaults.real_proxy_class;
      im = mono_class_get_method_from_name (D.27078, "PrivateInvoke", 4);
      D.27079 = im == 0B;
      D.27080 = (long int) D.27079;
      D.27081 = __builtin_expect (D.27080, 0);
      if (D.27081 != 0) goto <D.27082>; else goto <D.27083>;
      <D.27082>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 5966, "im");
      <D.27083>:
      D.27074 = real_proxy->vtable;
      D.27075 = D.27074->domain;
      D.27075->private_invoke_method = im;
      <D.27077>:
      pa[0] = real_proxy;
      pa[1] = msg;
      pa[2] = exc;
      pa[3] = out_args;
      D.27084 = mono_runtime_invoke (im, 0B, &pa, exc);
      return D.27084;
    }
  finally
    {
      pa = {CLOBBER};
    }
}


mono_message_invoke (struct MonoObject * target, struct MonoMethodMessage * msg, struct MonoObject * * exc, struct MonoArray * * out_args)
{
  struct MonoVTable * D.27089;
  struct MonoClass * D.27090;
  struct MonoClass * D.27091;
  struct MonoRemoteClass * D.27096;
  struct MonoClass * D.27097;
  unsigned char D.27098;
  unsigned char D.27099;
  struct MonoRealProxy * D.27101;
  struct MonoObject * D.27102;
  struct MonoAppContext * D.27103;
  struct MonoObject * D.27105;
  struct MonoReflectionMethod * D.27106;
  struct MonoType * D.27107;
  unsigned char D.27108;
  unsigned char D.27109;
  short unsigned int D.27112;
  int D.27113;
  struct MonoClass * object_array_klass.230;
  struct MonoClass * D.27117;
  _Bool D.27118;
  long int D.27119;
  long int D.27120;
  struct MonoVTable * D.27123;
  unsigned int outarg_count.231;
  struct MonoArray * D.27125;
  void * iftmp.232;
  struct MonoClass * D.27127;
  unsigned char D.27128;
  unsigned char D.27129;
  struct MonoArray * D.27133;
  unsigned int i.233;
  char * D.27137;
  struct MonoArray * D.27138;
  unsigned int j.234;
  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.27087>; else goto <D.27088>;
  <D.27087>:
  D.27089 = target->vtable;
  D.27090 = D.27089->klass;
  D.27091 = mono_defaults.transparent_proxy_class;
  if (D.27090 == D.27091) goto <D.27092>; else goto <D.27093>;
  <D.27092>:
  {
    struct MonoTransparentProxy * tp;

    tp = target;
    D.27096 = tp->remote_class;
    D.27097 = D.27096->proxy_class;
    D.27098 = BIT_FIELD_REF <*D.27097, 8, 176>;
    D.27099 = D.27098 & 128;
    if (D.27099 != 0) goto <D.27100>; else goto <D.27094>;
    <D.27100>:
    D.27101 = tp->rp;
    D.27102 = D.27101->context;
    D.27103 = mono_context_get ();
    if (D.27102 == D.27103) goto <D.27104>; else goto <D.27094>;
    <D.27104>:
    D.27101 = tp->rp;
    target = D.27101->unwrapped_server;
    goto <D.27095>;
    <D.27094>:
    D.27101 = tp->rp;
    D.27105 = mono_remoting_invoke (D.27101, msg, exc, out_args);
    return D.27105;
    <D.27095>:
  }
  <D.27093>:
  <D.27088>:
  domain = mono_domain_get ();
  D.27106 = msg->method;
  method = D.27106->method;
  sig = mono_method_signature (method);
  i = 0;
  goto <D.22792>;
  <D.22791>:
  D.27107 = sig->params[i];
  D.27108 = BIT_FIELD_REF <*D.27107, 8, 56>;
  D.27109 = D.27108 & 64;
  if (D.27109 != 0) goto <D.27110>; else goto <D.27111>;
  <D.27110>:
  outarg_count = outarg_count + 1;
  <D.27111>:
  i = i + 1;
  <D.22792>:
  D.27112 = sig->param_count;
  D.27113 = (int) D.27112;
  if (D.27113 > i) goto <D.22791>; else goto <D.22793>;
  <D.22793>:
  object_array_klass.230 = object_array_klass;
  if (object_array_klass.230 == 0B) goto <D.27115>; else goto <D.27116>;
  <D.27115>:
  {
    struct MonoClass * klass;

    D.27117 = mono_defaults.object_class;
    klass = mono_array_class_get (D.27117, 1);
    D.27118 = klass == 0B;
    D.27119 = (long int) D.27118;
    D.27120 = __builtin_expect (D.27119, 0);
    if (D.27120 != 0) goto <D.27121>; else goto <D.27122>;
    <D.27121>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 6014, "klass");
    <D.27122>:
    mono_memory_barrier ();
    object_array_klass = klass;
  }
  <D.27116>:
  object_array_klass.230 = object_array_klass;
  D.27123 = mono_class_vtable (domain, object_array_klass.230);
  outarg_count.231 = (unsigned int) outarg_count;
  D.27125 = mono_array_new_specific (D.27123, outarg_count.231);
  *out_args = D.27125;
  *exc = 0B;
  D.27127 = method->klass;
  D.27128 = BIT_FIELD_REF <*D.27127, 8, 160>;
  D.27129 = D.27128 & 8;
  if (D.27129 != 0) goto <D.27130>; else goto <D.27131>;
  <D.27130>:
  iftmp.232 = mono_object_unbox (target);
  goto <D.27132>;
  <D.27131>:
  iftmp.232 = target;
  <D.27132>:
  D.27133 = msg->args;
  ret = mono_runtime_invoke_array (method, iftmp.232, D.27133, exc);
  i = 0;
  j = 0;
  goto <D.22798>;
  <D.22797>:
  D.27107 = sig->params[i];
  D.27108 = BIT_FIELD_REF <*D.27107, 8, 56>;
  D.27109 = D.27108 & 64;
  if (D.27109 != 0) goto <D.27134>; else goto <D.27135>;
  <D.27134>:
  {
    struct MonoObject * arg;

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

      D.27138 = *out_args;
      j.234 = (unsigned int) j;
      __p = mono_array_addr_with_size (D.27138, 4, j.234);
      D.27138 = *out_args;
      mono_gc_wbarrier_set_arrayref (D.27138, __p, arg);
    }
    j = j + 1;
  }
  <D.27135>:
  i = i + 1;
  <D.22798>:
  D.27112 = sig->param_count;
  D.27113 = (int) D.27112;
  if (D.27113 > i) goto <D.22797>; else goto <D.22799>;
  <D.22799>:
  D.27105 = ret;
  return D.27105;
}


mono_object_to_string (struct MonoObject * obj, struct MonoObject * * exc)
{
  _Bool D.27141;
  long int D.27142;
  long int D.27143;
  struct MonoMethod * to_string.235;
  struct MonoClass * D.27149;
  struct MonoMethod * to_string.236;
  struct MonoClass * D.27151;
  int D.27152;
  struct MonoString * D.27155;
  static struct MonoMethod * to_string = 0B;
  struct MonoMethod * method;
  void * target;

  target = obj;
  D.27141 = obj == 0B;
  D.27142 = (long int) D.27141;
  D.27143 = __builtin_expect (D.27142, 0);
  if (D.27143 != 0) goto <D.27144>; else goto <D.27145>;
  <D.27144>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 6052, "obj");
  <D.27145>:
  to_string.235 = to_string;
  if (to_string.235 == 0B) goto <D.27147>; else goto <D.27148>;
  <D.27147>:
  D.27149 = mono_get_object_class ();
  to_string.236 = mono_class_get_method_from_name_flags (D.27149, "ToString", 0, 70);
  to_string = to_string.236;
  <D.27148>:
  to_string.235 = to_string;
  method = mono_object_get_virtual_method (obj, to_string.235);
  D.27151 = mono_method_get_class (method);
  D.27152 = mono_class_is_valuetype (D.27151);
  if (D.27152 != 0) goto <D.27153>; else goto <D.27154>;
  <D.27153>:
  target = mono_object_unbox (obj);
  <D.27154>:
  D.27155 = mono_runtime_invoke (method, target, 0B, exc);
  return D.27155;
}


mono_print_unhandled_exception (struct MonoObject * exc)
{
  struct MonoVTable * D.27157;
  struct MonoDomain * D.27158;
  struct MonoException * D.27159;
  struct MonoArray * D.27163;
  struct MonoObject * other_exc.237;
  int D.27173;
  struct MonoString * str;
  char * message;
  gboolean free_message;
  struct MonoError error;

  try
    {
      message = "";
      free_message = 0;
      D.27157 = exc->vtable;
      D.27158 = D.27157->domain;
      D.27159 = D.27158->out_of_memory_ex;
      if (D.27159 == exc) goto <D.27160>; else goto <D.27161>;
      <D.27160>:
      message = monoeg_strdup ("OutOfMemoryException");
      free_message = 1;
      goto <D.27162>;
      <D.27161>:
      D.27163 = MEM[(struct MonoException *)exc].native_trace_ips;
      if (D.27163 != 0B) goto <D.27164>; else goto <D.27165>;
      <D.27164>:
      message = mono_exception_get_native_backtrace (exc);
      free_message = 1;
      goto <D.27166>;
      <D.27165>:
      {
        struct MonoObject * other_exc;

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

              original_backtrace = mono_exception_get_managed_backtrace (exc);
              other_exc.237 = other_exc;
              nested_backtrace = mono_exception_get_managed_backtrace (other_exc.237);
              message = monoeg_g_strdup_printf ("Nested exception detected.\nOriginal Exception: %s\nNested exception:%s\n", original_backtrace, nested_backtrace);
              monoeg_g_free (original_backtrace);
              monoeg_g_free (nested_backtrace);
              free_message = 1;
            }
            goto <D.27170>;
            <D.27169>:
            if (str != 0B) goto <D.27171>; else goto <D.27172>;
            <D.27171>:
            message = mono_string_to_utf8_checked (str, &error);
            D.27173 = mono_error_ok (&error);
            if (D.27173 == 0) goto <D.27174>; else goto <D.27175>;
            <D.27174>:
            mono_error_cleanup (&error);
            message = "";
            goto <D.27176>;
            <D.27175>:
            free_message = 1;
            <D.27176>:
            <D.27172>:
            <D.27170>:
          }
        finally
          {
            other_exc = {CLOBBER};
          }
      }
      <D.27166>:
      <D.27162>:
      monoeg_g_printerr ("\nUnhandled Exception:\n%s\n", message);
      if (free_message != 0) goto <D.27177>; else goto <D.27178>;
      <D.27177>:
      monoeg_g_free (message);
      <D.27178>:
    }
  finally
    {
      error = {CLOBBER};
    }
}


mono_delegate_ctor_with_method (struct MonoObject * this, struct MonoObject * target, void * addr, struct MonoMethod * method)
{
  _Bool D.27179;
  long int D.27180;
  long int D.27181;
  _Bool D.27184;
  long int D.27185;
  long int D.27186;
  struct MonoVTable * D.27191;
  long unsigned int D.27192;
  long unsigned int D.27193;
  struct MonoVTable * D.27197;
  struct MonoClass * D.27198;
  struct MonoClass * D.27199;
  _Bool D.27201;
  long int D.27202;
  long int D.27203;
  void * D.27206;
  struct MonoObject * * D.27207;
  void * (*<T27a4>) (struct MonoDomain *, struct MonoClass *) arch_create_delegate_trampoline.238;
  struct MonoVTable * D.27209;
  struct MonoDomain * D.27210;
  struct MonoClass * D.27211;
  void * D.27212;
  struct MonoDelegate * delegate;
  struct MonoClass * class;

  delegate = this;
  D.27179 = this == 0B;
  D.27180 = (long int) D.27179;
  D.27181 = __builtin_expect (D.27180, 0);
  if (D.27181 != 0) goto <D.27182>; else goto <D.27183>;
  <D.27182>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 6142, "this");
  <D.27183>:
  D.27184 = addr == 0B;
  D.27185 = (long int) D.27184;
  D.27186 = __builtin_expect (D.27185, 0);
  if (D.27186 != 0) goto <D.27187>; else goto <D.27188>;
  <D.27187>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 6143, "addr");
  <D.27188>:
  if (method != 0B) goto <D.27189>; else goto <D.27190>;
  <D.27189>:
  delegate->method = method;
  <D.27190>:
  D.27191 = this->vtable;
  class = D.27191->klass;
  D.27192 = mono_stats.delegate_creations;
  D.27193 = D.27192 + 1;
  mono_stats.delegate_creations = D.27193;
  if (target != 0B) goto <D.27196>; else goto <D.27194>;
  <D.27196>:
  D.27197 = target->vtable;
  D.27198 = D.27197->klass;
  D.27199 = mono_defaults.transparent_proxy_class;
  if (D.27198 == D.27199) goto <D.27200>; else goto <D.27194>;
  <D.27200>:
  D.27201 = method == 0B;
  D.27202 = (long int) D.27201;
  D.27203 = __builtin_expect (D.27202, 0);
  if (D.27203 != 0) goto <D.27204>; else goto <D.27205>;
  <D.27204>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 6153, "method");
  <D.27205>:
  method = mono_marshal_get_remoting_invoke (method);
  D.27206 = mono_compile_method (method);
  delegate->method_ptr = D.27206;
  D.27207 = &delegate->target;
  mono_gc_wbarrier_set_field (delegate, D.27207, target);
  goto <D.27195>;
  <D.27194>:
  delegate->method_ptr = addr;
  D.27207 = &delegate->target;
  mono_gc_wbarrier_set_field (delegate, D.27207, target);
  <D.27195>:
  arch_create_delegate_trampoline.238 = arch_create_delegate_trampoline;
  D.27209 = delegate->object.vtable;
  D.27210 = D.27209->domain;
  D.27209 = delegate->object.vtable;
  D.27211 = D.27209->klass;
  D.27212 = arch_create_delegate_trampoline.238 (D.27210, D.27211);
  delegate->invoke_impl = D.27212;
}


mono_delegate_ctor (struct MonoObject * this, struct MonoObject * target, void * addr)
{
  _Bool D.27213;
  long int D.27214;
  long int D.27215;
  void * D.27218;
  struct MonoDomain * D.27221;
  struct MonoDomain * D.27224;
  void * D.27225;
  struct MonoClass * D.27228;
  struct MonoGenericContainer * D.27229;
  _Bool D.27230;
  long int D.27231;
  long int D.27232;
  struct MonoDomain * domain;
  struct MonoJitInfo * ji;
  struct MonoMethod * method;

  domain = mono_domain_get ();
  method = 0B;
  D.27213 = addr == 0B;
  D.27214 = (long int) D.27213;
  D.27215 = __builtin_expect (D.27214, 0);
  if (D.27215 != 0) goto <D.27216>; else goto <D.27217>;
  <D.27216>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 6182, "addr");
  <D.27217>:
  D.27218 = mono_get_addr_from_ftnptr (addr);
  ji = mono_jit_info_table_find (domain, D.27218);
  if (ji == 0B) goto <D.27219>; else goto <D.27220>;
  <D.27219>:
  D.27221 = mono_get_root_domain ();
  if (D.27221 != domain) goto <D.27222>; else goto <D.27223>;
  <D.27222>:
  D.27224 = mono_get_root_domain ();
  D.27225 = mono_get_addr_from_ftnptr (addr);
  ji = mono_jit_info_table_find (D.27224, D.27225);
  <D.27223>:
  <D.27220>:
  if (ji != 0B) goto <D.27226>; else goto <D.27227>;
  <D.27226>:
  method = mono_jit_info_get_method (ji);
  D.27228 = method->klass;
  D.27229 = D.27228->generic_container;
  D.27230 = D.27229 != 0B;
  D.27231 = (long int) D.27230;
  D.27232 = __builtin_expect (D.27231, 0);
  if (D.27232 != 0) goto <D.27233>; else goto <D.27234>;
  <D.27233>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 6190, "!method->klass->generic_container");
  <D.27234>:
  <D.27227>:
  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.27235;
  struct MonoReflectionMethod * D.27238;
  short unsigned int D.27239;
  int D.27240;
  struct MonoReflectionMethod * D.27242;
  struct MonoType * D.27243;
  unsigned char D.27244;
  unsigned char D.27245;
  unsigned int i.239;
  unsigned int D.27249;
  void * * D.27250;
  void * D.27251;
  unsigned char D.27253;
  unsigned char D.27254;
  unsigned char D.27255;
  struct MonoArray * D.27259;
  unsigned int i.240;
  _Bool D.27261;
  _Bool D.27262;
  _Bool D.27263;
  struct MonoDelegate * D.27266;
  struct MonoObject * D.27267;
  struct MonoMethodMessage * D.27268;
  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.27235 = mono_defaults.mono_method_message_class;
  msg = mono_object_new (domain, D.27235);
  if (invoke != 0B) goto <D.27236>; else goto <D.27237>;
  <D.27236>:
  D.27238 = mono_method_get_object (domain, invoke, 0B);
  mono_message_init (domain, msg, D.27238, 0B);
  D.27239 = sig->param_count;
  D.27240 = (int) D.27239;
  count = D.27240 + -2;
  goto <D.27241>;
  <D.27237>:
  D.27242 = mono_method_get_object (domain, method, 0B);
  mono_message_init (domain, msg, D.27242, 0B);
  D.27239 = sig->param_count;
  count = (int) D.27239;
  <D.27241>:
  i = 0;
  goto <D.22851>;
  <D.22850>:
  {
    void * vpos;
    struct MonoClass * class;
    struct MonoObject * arg;

    D.27243 = sig->params[i];
    D.27244 = BIT_FIELD_REF <*D.27243, 8, 56>;
    D.27245 = D.27244 & 64;
    if (D.27245 != 0) goto <D.27246>; else goto <D.27247>;
    <D.27246>:
    i.239 = (unsigned int) i;
    D.27249 = i.239 * 4;
    D.27250 = params + D.27249;
    D.27251 = *D.27250;
    vpos = MEM[(void * *)D.27251];
    goto <D.27252>;
    <D.27247>:
    i.239 = (unsigned int) i;
    D.27249 = i.239 * 4;
    D.27250 = params + D.27249;
    vpos = *D.27250;
    <D.27252>:
    D.27243 = sig->params[i];
    D.27253 = D.27243->type;
    type = (int) D.27253;
    D.27243 = sig->params[i];
    class = mono_class_from_mono_type (D.27243);
    D.27254 = BIT_FIELD_REF <*class, 8, 160>;
    D.27255 = D.27254 & 8;
    if (D.27255 != 0) goto <D.27256>; else goto <D.27257>;
    <D.27256>:
    arg = mono_value_box (domain, class, vpos);
    goto <D.27258>;
    <D.27257>:
    arg = MEM[(struct MonoObject * *)vpos];
    <D.27258>:
    {
      void * * __p;

      D.27259 = msg->args;
      i.240 = (unsigned int) i;
      __p = mono_array_addr_with_size (D.27259, 4, i.240);
      D.27259 = msg->args;
      mono_gc_wbarrier_set_arrayref (D.27259, __p, arg);
    }
  }
  i = i + 1;
  <D.22851>:
  if (i < count) goto <D.22850>; else goto <D.22852>;
  <D.22852>:
  D.27261 = cb != 0B;
  D.27262 = state != 0B;
  D.27263 = D.27261 & D.27262;
  if (D.27263 != 0) goto <D.27264>; else goto <D.27265>;
  <D.27264>:
  i.239 = (unsigned int) i;
  D.27249 = i.239 * 4;
  D.27250 = params + D.27249;
  D.27251 = *D.27250;
  D.27266 = MEM[(struct MonoDelegate * *)D.27251];
  *cb = D.27266;
  i = i + 1;
  i.239 = (unsigned int) i;
  D.27249 = i.239 * 4;
  D.27250 = params + D.27249;
  D.27251 = *D.27250;
  D.27267 = MEM[(struct MonoObject * *)D.27251];
  *state = D.27267;
  <D.27265>:
  D.27268 = msg;
  return D.27268;
}


mono_method_return_message_restore (struct MonoMethod * method, void * * params, struct MonoArray * out_args)
{
  unsigned int D.27272;
  unsigned char D.27275;
  unsigned char D.27276;
  struct MonoException * D.27281;
  unsigned int j.241;
  char * D.27283;
  unsigned char D.27284;
  _Bool D.27285;
  long int D.27286;
  long int D.27287;
  int D.27290;
  unsigned int i.242;
  unsigned int D.27294;
  void * * D.27295;
  void * D.27296;
  struct MonoObject * * D.27297;
  struct MonoVTable * D.27301;
  unsigned char D.27302;
  unsigned char D.27303;
  void * D.27306;
  void * D.27307;
  const void * D.27309;
  unsigned int size.243;
  struct MonoClass * D.27312;
  short unsigned int D.27313;
  int D.27314;
  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.27270>; else goto <D.27271>;
  <D.27270>:
  return;
  <D.27271>:
  D.27272 = mono_array_length (out_args);
  out_len = (int) D.27272;
  if (out_len == 0) goto <D.27273>; else goto <D.27274>;
  <D.27273>:
  return;
  <D.27274>:
  i = 0;
  j = 0;
  goto <D.22868>;
  <D.22867>:
  {
    struct MonoType * pt;

    pt = sig->params[i];
    D.27275 = BIT_FIELD_REF <*pt, 8, 56>;
    D.27276 = D.27275 & 64;
    if (D.27276 != 0) goto <D.27277>; else goto <D.27278>;
    <D.27277>:
    {
      char * arg;

      if (j >= out_len) goto <D.27279>; else goto <D.27280>;
      <D.27279>:
      D.27281 = mono_get_exception_execution_engine ("The proxy call returned an incorrect number of output arguments");
      mono_raise_exception (D.27281);
      <D.27280>:
      j.241 = (unsigned int) j;
      D.27283 = mono_array_addr_with_size (out_args, 4, j.241);
      arg = MEM[(void * *)D.27283];
      D.27284 = pt->type;
      type = (int) D.27284;
      D.27285 = type == 1;
      D.27286 = (long int) D.27285;
      D.27287 = __builtin_expect (D.27286, 0);
      if (D.27287 != 0) goto <D.27288>; else goto <D.27289>;
      <D.27288>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 6283, "type != MONO_TYPE_VOID");
      <D.27289>:
      D.27290 = mono_type_is_reference (pt);
      if (D.27290 != 0) goto <D.27291>; else goto <D.27292>;
      <D.27291>:
      i.242 = (unsigned int) i;
      D.27294 = i.242 * 4;
      D.27295 = params + D.27294;
      D.27296 = *D.27295;
      D.27297 = MEM[(struct MonoObject * * *)D.27296];
      mono_gc_wbarrier_generic_store (D.27297, arg);
      goto <D.27298>;
      <D.27292>:
      if (arg != 0B) goto <D.27299>; else goto <D.27300>;
      <D.27299>:
      {
        struct MonoClass * class;

        D.27301 = MEM[(struct MonoObject *)arg].vtable;
        class = D.27301->klass;
        size = mono_class_value_size (class, 0B);
        D.27302 = BIT_FIELD_REF <*class, 8, 184>;
        D.27303 = D.27302 & 8;
        if (D.27303 != 0) goto <D.27304>; else goto <D.27305>;
        <D.27304>:
        i.242 = (unsigned int) i;
        D.27294 = i.242 * 4;
        D.27295 = params + D.27294;
        D.27296 = *D.27295;
        D.27306 = MEM[(void * *)D.27296];
        D.27307 = arg + 8;
        mono_gc_wbarrier_value_copy (D.27306, D.27307, 1, class);
        goto <D.27308>;
        <D.27305>:
        i.242 = (unsigned int) i;
        D.27294 = i.242 * 4;
        D.27295 = params + D.27294;
        D.27296 = *D.27295;
        D.27306 = MEM[(void * *)D.27296];
        D.27309 = arg + 8;
        size.243 = (unsigned int) size;
        mono_gc_memmove_atomic (D.27306, D.27309, size.243);
        <D.27308>:
      }
      goto <D.27311>;
      <D.27300>:
      D.27312 = mono_class_from_mono_type (pt);
      size = mono_class_value_size (D.27312, 0B);
      i.242 = (unsigned int) i;
      D.27294 = i.242 * 4;
      D.27295 = params + D.27294;
      D.27296 = *D.27295;
      D.27306 = MEM[(void * *)D.27296];
      size.243 = (unsigned int) size;
      mono_gc_bzero_atomic (D.27306, size.243);
      <D.27311>:
      <D.27298>:
      j = j + 1;
    }
    <D.27278>:
  }
  i = i + 1;
  <D.22868>:
  D.27313 = sig->param_count;
  D.27314 = (int) D.27313;
  if (D.27314 > i) goto <D.22867>; else goto <D.22869>;
  <D.22869>:
}


mono_load_remote_field (struct MonoObject * this, struct MonoClass * klass, struct MonoClassField * field, void * * res)
{
  struct MonoVTable * D.27316;
  struct MonoClass * D.27317;
  struct MonoClass * D.27318;
  _Bool D.27319;
  long int D.27320;
  long int D.27321;
  _Bool D.27324;
  long int D.27325;
  long int D.27326;
  struct MonoRemoteClass * D.27329;
  struct MonoClass * D.27330;
  unsigned char D.27331;
  unsigned char D.27332;
  struct MonoRealProxy * D.27335;
  struct MonoObject * D.27336;
  struct MonoAppContext * D.27337;
  struct MonoObject * D.27340;
  void * D.27341;
  struct MonoMethod * getter.244;
  struct MonoClass * D.27345;
  struct MonoMethod * getter.245;
  _Bool D.27347;
  long int D.27348;
  long int D.27349;
  struct MonoType * D.27352;
  struct MonoClass * D.27353;
  struct MonoArray * out_args.246;
  struct MonoReflectionMethod * D.27355;
  struct MonoArray * out_args.247;
  struct MonoArray * D.27357;
  struct MonoString * D.27358;
  const char * D.27359;
  struct MonoString * D.27360;
  struct MonoObject * exc.248;
  unsigned int D.27364;
  char * D.27367;
  struct MonoObject * D.27368;
  unsigned char D.27369;
  unsigned char D.27370;
  void * D.27373;
  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.27316 = this->vtable;
      D.27317 = D.27316->klass;
      D.27318 = mono_defaults.transparent_proxy_class;
      D.27319 = D.27317 != D.27318;
      D.27320 = (long int) D.27319;
      D.27321 = __builtin_expect (D.27320, 0);
      if (D.27321 != 0) goto <D.27322>; else goto <D.27323>;
      <D.27322>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 6334, "mono_object_is_transparent_proxy (this)");
      <D.27323>:
      D.27324 = res == 0B;
      D.27325 = (long int) D.27324;
      D.27326 = __builtin_expect (D.27325, 0);
      if (D.27326 != 0) goto <D.27327>; else goto <D.27328>;
      <D.27327>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 6335, "res != NULL");
      <D.27328>:
      D.27329 = tp->remote_class;
      D.27330 = D.27329->proxy_class;
      D.27331 = BIT_FIELD_REF <*D.27330, 8, 176>;
      D.27332 = D.27331 & 128;
      if (D.27332 != 0) goto <D.27333>; else goto <D.27334>;
      <D.27333>:
      D.27335 = tp->rp;
      D.27336 = D.27335->context;
      D.27337 = mono_context_get ();
      if (D.27336 == D.27337) goto <D.27338>; else goto <D.27339>;
      <D.27338>:
      D.27335 = tp->rp;
      D.27340 = D.27335->unwrapped_server;
      mono_field_get_value (D.27340, field, res);
      D.27341 = res;
      return D.27341;
      <D.27339>:
      <D.27334>:
      getter.244 = getter;
      if (getter.244 == 0B) goto <D.27343>; else goto <D.27344>;
      <D.27343>:
      D.27345 = mono_defaults.object_class;
      getter.245 = mono_class_get_method_from_name (D.27345, "FieldGetter", -1);
      getter = getter.245;
      getter.244 = getter;
      D.27347 = getter.244 == 0B;
      D.27348 = (long int) D.27347;
      D.27349 = __builtin_expect (D.27348, 0);
      if (D.27349 != 0) goto <D.27350>; else goto <D.27351>;
      <D.27350>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 6344, "getter");
      <D.27351>:
      <D.27344>:
      D.27352 = field->type;
      field_class = mono_class_from_mono_type (D.27352);
      D.27353 = mono_defaults.mono_method_message_class;
      msg = mono_object_new (domain, D.27353);
      D.27345 = mono_defaults.object_class;
      out_args.246 = mono_array_new (domain, D.27345, 1);
      out_args = out_args.246;
      getter.244 = getter;
      D.27355 = mono_method_get_object (domain, getter.244, 0B);
      out_args.247 = out_args;
      mono_message_init (domain, msg, D.27355, out_args.247);
      full_name = mono_type_get_full_name (klass);
      {
        void * * __p;

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

        D.27357 = msg->args;
        __p = mono_array_addr_with_size (D.27357, 4, 1);
        D.27357 = msg->args;
        D.27359 = mono_field_get_name (field);
        D.27360 = mono_string_new (domain, D.27359);
        mono_gc_wbarrier_set_arrayref (D.27357, __p, D.27360);
      }
      monoeg_g_free (full_name);
      D.27335 = tp->rp;
      mono_remoting_invoke (D.27335, msg, &exc, &out_args);
      exc.248 = exc;
      if (exc.248 != 0B) goto <D.27362>; else goto <D.27363>;
      <D.27362>:
      exc.248 = exc;
      mono_raise_exception (exc.248);
      <D.27363>:
      out_args.247 = out_args;
      D.27364 = mono_array_length (out_args.247);
      if (D.27364 == 0) goto <D.27365>; else goto <D.27366>;
      <D.27365>:
      D.27341 = 0B;
      return D.27341;
      <D.27366>:
      out_args.247 = out_args;
      D.27367 = mono_array_addr_with_size (out_args.247, 4, 0);
      D.27368 = MEM[(struct MonoObject * *)D.27367];
      *res = D.27368;
      D.27369 = BIT_FIELD_REF <*field_class, 8, 160>;
      D.27370 = D.27369 & 8;
      if (D.27370 != 0) goto <D.27371>; else goto <D.27372>;
      <D.27371>:
      D.27373 = *res;
      D.27341 = D.27373 + 8;
      return D.27341;
      <D.27372>:
      D.27341 = res;
      return D.27341;
    }
  finally
    {
      out_args = {CLOBBER};
      exc = {CLOBBER};
    }
}


mono_load_remote_field_new (struct MonoObject * this, struct MonoClass * klass, struct MonoClassField * field)
{
  struct MonoVTable * D.27376;
  struct MonoClass * D.27377;
  struct MonoClass * D.27378;
  _Bool D.27379;
  long int D.27380;
  long int D.27381;
  struct MonoType * D.27384;
  struct MonoRemoteClass * D.27385;
  struct MonoClass * D.27386;
  unsigned char D.27387;
  unsigned char D.27388;
  struct MonoRealProxy * D.27391;
  struct MonoObject * D.27392;
  struct MonoAppContext * D.27393;
  unsigned char D.27396;
  unsigned char D.27397;
  struct MonoObject * res.249;
  struct MonoObject * res.250;
  struct MonoObject * D.27403;
  struct MonoObject * D.27404;
  struct MonoMethod * getter.251;
  struct MonoClass * D.27408;
  struct MonoMethod * getter.252;
  _Bool D.27410;
  long int D.27411;
  long int D.27412;
  struct MonoClass * D.27415;
  struct MonoArray * out_args.253;
  struct MonoReflectionMethod * D.27417;
  struct MonoArray * out_args.254;
  struct MonoArray * D.27419;
  struct MonoString * D.27420;
  const char * D.27421;
  struct MonoString * D.27422;
  struct MonoObject * exc.255;
  unsigned int D.27426;
  char * D.27430;
  struct MonoObject * res.256;
  static struct MonoMethod * getter = 0B;
  struct MonoDomain * domain;
  struct MonoTransparentProxy * tp;
  struct MonoClass * field_class;
  struct MonoMethodMessage * msg;
  struct MonoArray * out_args;
  struct MonoObject * exc;
  struct MonoObject * res;
  char * full_name;

  try
    {
      domain = mono_domain_get ();
      tp = this;
      D.27376 = this->vtable;
      D.27377 = D.27376->klass;
      D.27378 = mono_defaults.transparent_proxy_class;
      D.27379 = D.27377 != D.27378;
      D.27380 = (long int) D.27379;
      D.27381 = __builtin_expect (D.27380, 0);
      if (D.27381 != 0) goto <D.27382>; else goto <D.27383>;
      <D.27382>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 6393, "mono_object_is_transparent_proxy (this)");
      <D.27383>:
      D.27384 = field->type;
      field_class = mono_class_from_mono_type (D.27384);
      D.27385 = tp->remote_class;
      D.27386 = D.27385->proxy_class;
      D.27387 = BIT_FIELD_REF <*D.27386, 8, 176>;
      D.27388 = D.27387 & 128;
      if (D.27388 != 0) goto <D.27389>; else goto <D.27390>;
      <D.27389>:
      D.27391 = tp->rp;
      D.27392 = D.27391->context;
      D.27393 = mono_context_get ();
      if (D.27392 == D.27393) goto <D.27394>; else goto <D.27395>;
      <D.27394>:
      {
        void * val;

        D.27396 = BIT_FIELD_REF <*field_class, 8, 160>;
        D.27397 = D.27396 & 8;
        if (D.27397 != 0) goto <D.27398>; else goto <D.27399>;
        <D.27398>:
        res.249 = mono_object_new (domain, field_class);
        res = res.249;
        res.250 = res;
        val = res.250 + 8;
        goto <D.27402>;
        <D.27399>:
        val = &res;
        <D.27402>:
        D.27391 = tp->rp;
        D.27403 = D.27391->unwrapped_server;
        mono_field_get_value (D.27403, field, val);
        D.27404 = res;
        return D.27404;
      }
      <D.27395>:
      <D.27390>:
      getter.251 = getter;
      if (getter.251 == 0B) goto <D.27406>; else goto <D.27407>;
      <D.27406>:
      D.27408 = mono_defaults.object_class;
      getter.252 = mono_class_get_method_from_name (D.27408, "FieldGetter", -1);
      getter = getter.252;
      getter.251 = getter;
      D.27410 = getter.251 == 0B;
      D.27411 = (long int) D.27410;
      D.27412 = __builtin_expect (D.27411, 0);
      if (D.27412 != 0) goto <D.27413>; else goto <D.27414>;
      <D.27413>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 6411, "getter");
      <D.27414>:
      <D.27407>:
      D.27415 = mono_defaults.mono_method_message_class;
      msg = mono_object_new (domain, D.27415);
      D.27408 = mono_defaults.object_class;
      out_args.253 = mono_array_new (domain, D.27408, 1);
      out_args = out_args.253;
      getter.251 = getter;
      D.27417 = mono_method_get_object (domain, getter.251, 0B);
      out_args.254 = out_args;
      mono_message_init (domain, msg, D.27417, out_args.254);
      full_name = mono_type_get_full_name (klass);
      {
        void * * __p;

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

        D.27419 = msg->args;
        __p = mono_array_addr_with_size (D.27419, 4, 1);
        D.27419 = msg->args;
        D.27421 = mono_field_get_name (field);
        D.27422 = mono_string_new (domain, D.27421);
        mono_gc_wbarrier_set_arrayref (D.27419, __p, D.27422);
      }
      monoeg_g_free (full_name);
      D.27391 = tp->rp;
      mono_remoting_invoke (D.27391, msg, &exc, &out_args);
      exc.255 = exc;
      if (exc.255 != 0B) goto <D.27424>; else goto <D.27425>;
      <D.27424>:
      exc.255 = exc;
      mono_raise_exception (exc.255);
      <D.27425>:
      out_args.254 = out_args;
      D.27426 = mono_array_length (out_args.254);
      if (D.27426 == 0) goto <D.27427>; else goto <D.27428>;
      <D.27427>:
      res = 0B;
      goto <D.27429>;
      <D.27428>:
      out_args.254 = out_args;
      D.27430 = mono_array_addr_with_size (out_args.254, 4, 0);
      res.256 = MEM[(struct MonoObject * *)D.27430];
      res = res.256;
      <D.27429>:
      D.27404 = res;
      return D.27404;
    }
  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.27434;
  struct MonoClass * D.27435;
  struct MonoClass * D.27436;
  _Bool D.27437;
  long int D.27438;
  long int D.27439;
  struct MonoType * D.27442;
  struct MonoRemoteClass * D.27443;
  struct MonoClass * D.27444;
  unsigned char D.27445;
  unsigned char D.27446;
  struct MonoRealProxy * D.27449;
  struct MonoObject * D.27450;
  struct MonoAppContext * D.27451;
  unsigned char D.27454;
  unsigned char D.27455;
  struct MonoObject * D.27458;
  struct MonoObject * D.27460;
  struct MonoMethod * setter.257;
  struct MonoClass * D.27464;
  struct MonoMethod * setter.258;
  _Bool D.27466;
  long int D.27467;
  long int D.27468;
  struct MonoClass * D.27474;
  struct MonoReflectionMethod * D.27475;
  struct MonoArray * D.27476;
  struct MonoString * D.27477;
  const char * D.27478;
  struct MonoString * D.27479;
  struct MonoObject * exc.259;
  static struct MonoMethod * setter = 0B;
  struct MonoDomain * domain;
  struct MonoTransparentProxy * tp;
  struct MonoClass * field_class;
  struct MonoMethodMessage * msg;
  struct MonoArray * out_args;
  struct MonoObject * exc;
  struct MonoObject * arg;
  char * full_name;

  try
    {
      domain = mono_domain_get ();
      tp = this;
      D.27434 = this->vtable;
      D.27435 = D.27434->klass;
      D.27436 = mono_defaults.transparent_proxy_class;
      D.27437 = D.27435 != D.27436;
      D.27438 = (long int) D.27437;
      D.27439 = __builtin_expect (D.27438, 0);
      if (D.27439 != 0) goto <D.27440>; else goto <D.27441>;
      <D.27440>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 6460, "mono_object_is_transparent_proxy (this)");
      <D.27441>:
      D.27442 = field->type;
      field_class = mono_class_from_mono_type (D.27442);
      D.27443 = tp->remote_class;
      D.27444 = D.27443->proxy_class;
      D.27445 = BIT_FIELD_REF <*D.27444, 8, 176>;
      D.27446 = D.27445 & 128;
      if (D.27446 != 0) goto <D.27447>; else goto <D.27448>;
      <D.27447>:
      D.27449 = tp->rp;
      D.27450 = D.27449->context;
      D.27451 = mono_context_get ();
      if (D.27450 == D.27451) goto <D.27452>; else goto <D.27453>;
      <D.27452>:
      D.27454 = BIT_FIELD_REF <*field_class, 8, 160>;
      D.27455 = D.27454 & 8;
      if (D.27455 != 0) goto <D.27456>; else goto <D.27457>;
      <D.27456>:
      D.27449 = tp->rp;
      D.27458 = D.27449->unwrapped_server;
      mono_field_set_value (D.27458, field, val);
      goto <D.27459>;
      <D.27457>:
      D.27449 = tp->rp;
      D.27458 = D.27449->unwrapped_server;
      D.27460 = MEM[(struct MonoObject * *)val];
      mono_field_set_value (D.27458, field, D.27460);
      <D.27459>:
      return;
      <D.27453>:
      <D.27448>:
      setter.257 = setter;
      if (setter.257 == 0B) goto <D.27462>; else goto <D.27463>;
      <D.27462>:
      D.27464 = mono_defaults.object_class;
      setter.258 = mono_class_get_method_from_name (D.27464, "FieldSetter", -1);
      setter = setter.258;
      setter.257 = setter;
      D.27466 = setter.257 == 0B;
      D.27467 = (long int) D.27466;
      D.27468 = __builtin_expect (D.27467, 0);
      if (D.27468 != 0) goto <D.27469>; else goto <D.27470>;
      <D.27469>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 6472, "setter");
      <D.27470>:
      <D.27463>:
      D.27454 = BIT_FIELD_REF <*field_class, 8, 160>;
      D.27455 = D.27454 & 8;
      if (D.27455 != 0) goto <D.27471>; else goto <D.27472>;
      <D.27471>:
      arg = mono_value_box (domain, field_class, val);
      goto <D.27473>;
      <D.27472>:
      arg = MEM[(struct MonoObject * *)val];
      <D.27473>:
      D.27474 = mono_defaults.mono_method_message_class;
      msg = mono_object_new (domain, D.27474);
      setter.257 = setter;
      D.27475 = mono_method_get_object (domain, setter.257, 0B);
      mono_message_init (domain, msg, D.27475, 0B);
      full_name = mono_type_get_full_name (klass);
      {
        void * * __p;

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

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

        D.27476 = msg->args;
        __p = mono_array_addr_with_size (D.27476, 4, 2);
        D.27476 = msg->args;
        mono_gc_wbarrier_set_arrayref (D.27476, __p, arg);
      }
      monoeg_g_free (full_name);
      D.27449 = tp->rp;
      mono_remoting_invoke (D.27449, msg, &exc, &out_args);
      exc.259 = exc;
      if (exc.259 != 0B) goto <D.27481>; else goto <D.27482>;
      <D.27481>:
      exc.259 = exc;
      mono_raise_exception (exc.259);
      <D.27482>:
    }
  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.27486;
  struct MonoClass * D.27487;
  struct MonoClass * D.27488;
  _Bool D.27489;
  long int D.27490;
  long int D.27491;
  struct MonoType * D.27494;
  struct MonoRemoteClass * D.27495;
  struct MonoClass * D.27496;
  unsigned char D.27497;
  unsigned char D.27498;
  struct MonoRealProxy * D.27501;
  struct MonoObject * D.27502;
  struct MonoAppContext * D.27503;
  unsigned char D.27506;
  unsigned char D.27507;
  struct MonoObject * D.27510;
  void * D.27511;
  struct MonoMethod * setter.260;
  struct MonoClass * D.27516;
  struct MonoMethod * setter.261;
  _Bool D.27518;
  long int D.27519;
  long int D.27520;
  struct MonoClass * D.27523;
  struct MonoReflectionMethod * D.27524;
  struct MonoArray * D.27525;
  struct MonoString * D.27526;
  const char * D.27527;
  struct MonoString * D.27528;
  struct MonoObject * exc.262;
  static struct MonoMethod * setter = 0B;
  struct MonoDomain * domain;
  struct MonoTransparentProxy * tp;
  struct MonoClass * field_class;
  struct MonoMethodMessage * msg;
  struct MonoArray * out_args;
  struct MonoObject * exc;
  char * full_name;

  try
    {
      domain = mono_domain_get ();
      tp = this;
      D.27486 = this->vtable;
      D.27487 = D.27486->klass;
      D.27488 = mono_defaults.transparent_proxy_class;
      D.27489 = D.27487 != D.27488;
      D.27490 = (long int) D.27489;
      D.27491 = __builtin_expect (D.27490, 0);
      if (D.27491 != 0) goto <D.27492>; else goto <D.27493>;
      <D.27492>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 6516, "mono_object_is_transparent_proxy (this)");
      <D.27493>:
      D.27494 = field->type;
      field_class = mono_class_from_mono_type (D.27494);
      D.27495 = tp->remote_class;
      D.27496 = D.27495->proxy_class;
      D.27497 = BIT_FIELD_REF <*D.27496, 8, 176>;
      D.27498 = D.27497 & 128;
      if (D.27498 != 0) goto <D.27499>; else goto <D.27500>;
      <D.27499>:
      D.27501 = tp->rp;
      D.27502 = D.27501->context;
      D.27503 = mono_context_get ();
      if (D.27502 == D.27503) goto <D.27504>; else goto <D.27505>;
      <D.27504>:
      D.27506 = BIT_FIELD_REF <*field_class, 8, 160>;
      D.27507 = D.27506 & 8;
      if (D.27507 != 0) goto <D.27508>; else goto <D.27509>;
      <D.27508>:
      D.27501 = tp->rp;
      D.27510 = D.27501->unwrapped_server;
      D.27511 = arg + 8;
      mono_field_set_value (D.27510, field, D.27511);
      goto <D.27512>;
      <D.27509>:
      D.27501 = tp->rp;
      D.27510 = D.27501->unwrapped_server;
      mono_field_set_value (D.27510, field, arg);
      <D.27512>:
      return;
      <D.27505>:
      <D.27500>:
      setter.260 = setter;
      if (setter.260 == 0B) goto <D.27514>; else goto <D.27515>;
      <D.27514>:
      D.27516 = mono_defaults.object_class;
      setter.261 = mono_class_get_method_from_name (D.27516, "FieldSetter", -1);
      setter = setter.261;
      setter.260 = setter;
      D.27518 = setter.260 == 0B;
      D.27519 = (long int) D.27518;
      D.27520 = __builtin_expect (D.27519, 0);
      if (D.27520 != 0) goto <D.27521>; else goto <D.27522>;
      <D.27521>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "object.c", 6528, "setter");
      <D.27522>:
      <D.27515>:
      D.27523 = mono_defaults.mono_method_message_class;
      msg = mono_object_new (domain, D.27523);
      setter.260 = setter;
      D.27524 = mono_method_get_object (domain, setter.260, 0B);
      mono_message_init (domain, msg, D.27524, 0B);
      full_name = mono_type_get_full_name (klass);
      {
        void * * __p;

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

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

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


mono_create_ftnptr (struct MonoDomain * domain, void * addr)
{
  void * D.27535;
  void * (*<T2f0f>) (struct MonoDomain *, void *) D.27536;

  D.27536 = callbacks.create_ftnptr;
  D.27535 = D.27536 (domain, addr);
  return D.27535;
}


mono_get_addr_from_ftnptr (void * descr)
{
  void * D.27538;
  void * (*<T1e9b>) (void *) D.27539;

  D.27539 = callbacks.get_addr_from_ftnptr;
  D.27538 = D.27539 (descr);
  return D.27538;
}


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

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


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

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


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

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


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

  D.27548 = &array->vector;
  size.263 = (unsigned int) size;
  D.27550 = size.263 * idx;
  D.27547 = D.27548 + D.27550;
  return D.27547;
}