__attribute__((visibility ("hidden")))
mono_gc_run_finalize (void * obj, void * data)
{
  long int data.0;
  unsigned int D.19153;
  sizetype D.19154;
  int suspend_finalizers.1;
  struct MonoVTable * D.19158;
  struct MonoClass * D.19159;
  struct MonoClass * D.19160;
  int D.19163;
  unsigned char D.19166;
  int finalizing_root_domain.2;
  struct MonoImage * D.19172;
  struct MonoImage * D.19173;
  const char * D.19176;
  int D.19177;
  int D.19182;
  struct MonoDomain * D.19185;
  long unsigned int D.19186;
  long unsigned int D.19187;
  void * D.19190;
  int D.19193;
  void * D.19198;
  struct MonoClass * D.19201;
  struct MonoMethod * D.19202;
  void * D.19203;
  struct MonoObject * exc.3;
  struct MonoObject * exc;
  struct MonoObject * o;
  struct MonoMethod * finalizer;
  struct MonoDomain * caller_domain;
  struct MonoDomain * domain;
  struct MonoObject * (*RuntimeInvokeFunction) (struct MonoObject *, void * *, struct MonoObject * *, void *) runtime_invoke;

  try
    {
      exc = 0B;
      finalizer = 0B;
      caller_domain = mono_domain_get ();
      data.0 = (long int) data;
      D.19153 = (unsigned int) data.0;
      D.19154 = (sizetype) D.19153;
      o = obj + D.19154;
      suspend_finalizers.1 = suspend_finalizers;
      if (suspend_finalizers.1 != 0) goto <D.19156>; else goto <D.19157>;
      <D.19156>:
      return;
      <D.19157>:
      D.19158 = o->vtable;
      domain = D.19158->domain;
      object_register_finalizer (obj, 0B);
      D.19158 = o->vtable;
      D.19159 = D.19158->klass;
      D.19160 = mono_defaults.internal_thread_class;
      if (D.19159 == D.19160) goto <D.19161>; else goto <D.19162>;
      <D.19161>:
      {
        struct MonoInternalThread * t;

        t = o;
        D.19163 = mono_gc_is_finalizer_internal_thread (t);
        if (D.19163 != 0) goto <D.19164>; else goto <D.19165>;
        <D.19164>:
        return;
        <D.19165>:
        D.19166 = t->threadpool_thread;
        if (D.19166 != 0) goto <D.19167>; else goto <D.19168>;
        <D.19167>:
        finalizing_root_domain.2 = finalizing_root_domain;
        if (finalizing_root_domain.2 != 0) goto <D.19170>; else goto <D.19171>;
        <D.19170>:
        add_thread_to_finalize (t);
        return;
        <D.19171>:
        <D.19168>:
      }
      <D.19162>:
      D.19158 = o->vtable;
      D.19159 = D.19158->klass;
      D.19172 = D.19159->image;
      D.19173 = mono_defaults.corlib;
      if (D.19172 == D.19173) goto <D.19174>; else goto <D.19175>;
      <D.19174>:
      D.19158 = o->vtable;
      D.19159 = D.19158->klass;
      D.19176 = D.19159->name;
      D.19177 = strcmp (D.19176, "DynamicMethod");
      if (D.19177 == 0) goto <D.19178>; else goto <D.19179>;
      <D.19178>:
      finalizing_root_domain.2 = finalizing_root_domain;
      if (finalizing_root_domain.2 != 0) goto <D.19180>; else goto <D.19181>;
      <D.19180>:
      return;
      <D.19181>:
      <D.19179>:
      <D.19175>:
      D.19182 = mono_runtime_get_no_exec ();
      if (D.19182 != 0) goto <D.19183>; else goto <D.19184>;
      <D.19183>:
      return;
      <D.19184>:
      D.19158 = o->vtable;
      D.19185 = D.19158->domain;
      mono_domain_set_internal (D.19185);
      D.19158 = o->vtable;
      D.19159 = D.19158->klass;
      D.19186 = BIT_FIELD_REF <*D.19159, 64, 256>;
      D.19187 = D.19186 & 549755813888;
      if (D.19187 != 0) goto <D.19188>; else goto <D.19189>;
      <D.19188>:
      {
        struct MonoDelegate * del;

        del = o;
        D.19190 = del->delegate_trampoline;
        if (D.19190 != 0B) goto <D.19191>; else goto <D.19192>;
        <D.19191>:
        mono_delegate_free_ftnptr (o);
        <D.19192>:
        mono_domain_set_internal (caller_domain);
        return;
      }
      <D.19189>:
      D.19158 = o->vtable;
      D.19159 = D.19158->klass;
      finalizer = mono_class_get_finalizer (D.19159);
      D.19193 = mono_marshal_free_ccw (o);
      if (D.19193 != 0) goto <D.19194>; else goto <D.19195>;
      <D.19194>:
      if (finalizer == 0B) goto <D.19196>; else goto <D.19197>;
      <D.19196>:
      mono_domain_set_internal (caller_domain);
      return;
      <D.19197>:
      <D.19195>:
      D.19198 = domain->finalize_runtime_invoke;
      if (D.19198 == 0B) goto <D.19199>; else goto <D.19200>;
      <D.19199>:
      {
        struct MonoMethod * invoke;

        D.19201 = mono_defaults.object_class;
        D.19202 = mono_class_get_method_from_name_flags (D.19201, "Finalize", 0, 0);
        invoke = mono_marshal_get_runtime_invoke (D.19202, 1);
        D.19203 = mono_compile_method (invoke);
        domain->finalize_runtime_invoke = D.19203;
      }
      <D.19200>:
      D.19198 = domain->finalize_runtime_invoke;
      runtime_invoke = (struct MonoObject * (*RuntimeInvokeFunction) (struct MonoObject *, void * *, struct MonoObject * *, void *)) D.19198;
      D.19158 = o->vtable;
      mono_runtime_class_init (D.19158);
      if (0 != 0) goto <D.19204>; else goto <D.19205>;
      <D.19204>:
      <D.19205>:
      runtime_invoke (o, 0B, &exc, 0B);
      exc.3 = exc;
      if (exc.3 != 0B) goto <D.19207>; else goto <D.19208>;
      <D.19207>:
      exc.3 = exc;
      mono_internal_thread_unhandled_exception (exc.3);
      <D.19208>:
      mono_domain_set_internal (caller_domain);
    }
  finally
    {
      exc = {CLOBBER};
    }
}


object_register_finalizer (struct MonoObject * obj, void (*<T10b>) (void *, void *) callback)
{
  struct MonoException * D.19214;
  struct MonoVTable * D.19215;
  int D.19216;
  struct MonoDomain * domain;

  if (obj == 0B) goto <D.19212>; else goto <D.19213>;
  <D.19212>:
  D.19214 = mono_get_exception_argument_null ("obj");
  mono_raise_exception (D.19214);
  <D.19213>:
  D.19215 = obj->vtable;
  domain = D.19215->domain;
  D.19216 = mono_domain_is_unloading (domain);
  if (D.19216 == 0) goto <D.19217>; else goto <D.19218>;
  <D.19217>:
  mono_gc_register_for_finalization (obj, callback);
  <D.19218>:
}


add_thread_to_finalize (struct MonoInternalThread * thread)
{
  _Bool D.19221;
  long int D.19222;
  long int D.19223;
  struct MonoMList * threads_to_finalize.4;
  void * D.19231;
  struct MonoMList * D.19232;
  _Bool D.19235;
  long int D.19236;
  long int D.19237;

  {
    int ret;

    ret = pthread_mutex_lock (&finalizer_mutex.mutex);
    if (ret != 0) goto <D.19219>; else goto <D.19220>;
    <D.19219>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
    <D.19220>:
    D.19221 = ret != 0;
    D.19222 = (long int) D.19221;
    D.19223 = __builtin_expect (D.19222, 0);
    if (D.19223 != 0) goto <D.19224>; else goto <D.19225>;
    <D.19224>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "gc.c", 88, "ret == 0");
    <D.19225>:
  }
  threads_to_finalize.4 = threads_to_finalize;
  if (threads_to_finalize.4 == 0B) goto <D.19227>; else goto <D.19228>;
  <D.19227>:
  if (0 != 0) goto <D.19229>; else goto <D.19230>;
  <D.19229>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "gc.c", 90, "sizeof (threads_to_finalize) == sizeof (MonoObject*)");
  <D.19230>:
  D.19231 = mono_gc_make_root_descr_all_refs (1);
  mono_gc_register_root (&threads_to_finalize, 8, D.19231);
  <D.19228>:
  threads_to_finalize.4 = threads_to_finalize;
  D.19232 = mono_mlist_append (threads_to_finalize.4, thread);
  threads_to_finalize = D.19232;
  {
    int ret;

    ret = pthread_mutex_unlock (&finalizer_mutex.mutex);
    if (ret != 0) goto <D.19233>; else goto <D.19234>;
    <D.19233>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.19234>:
    D.19235 = ret != 0;
    D.19236 = (long int) D.19235;
    D.19237 = __builtin_expect (D.19236, 0);
    if (D.19237 != 0) goto <D.19238>; else goto <D.19239>;
    <D.19238>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "gc.c", 92, "ret == 0");
    <D.19239>:
  }
}


__attribute__((__gnu_inline__, nothrow, leaf, pure))
strcmp (const char * __s1, const char * __s2)
{
  int iftmp.5;
  int iftmp.6;
  int D.19248;
  char * __p1;
  char * __p2;
  int __ret;

  __p1 = __s1;
  __p2 = __s2;
  __asm__ __volatile__("   slr   0,0
0: clst  %1,%2
   jo    0b
   ipm   %0
   srl   %0,28" : "=d" __ret, "=&a" __p1, "=&a" __p2 : "1" __p1, "2" __p2 : "0", "memory", "cc");
  if (__ret != 0) goto <D.19241>; else goto <D.19242>;
  <D.19241>:
  if (__ret == 1) goto <D.19244>; else goto <D.19245>;
  <D.19244>:
  iftmp.6 = -1;
  goto <D.19246>;
  <D.19245>:
  iftmp.6 = 1;
  <D.19246>:
  iftmp.5 = iftmp.6;
  goto <D.19247>;
  <D.19242>:
  iftmp.5 = 0;
  <D.19247>:
  __ret = iftmp.5;
  D.19248 = __ret;
  return D.19248;
}


__attribute__((visibility ("hidden")))
mono_gc_finalize_threadpool_threads ()
{
  struct MonoMList * threads_to_finalize.7;
  struct MonoMList * D.19251;

  goto <D.18812>;
  <D.18811>:
  {
    struct MonoInternalThread * thread;

    threads_to_finalize.7 = threads_to_finalize;
    thread = mono_mlist_get_data (threads_to_finalize.7);
    thread->threadpool_thread = 0;
    mono_object_register_finalizer (thread);
    mono_gc_run_finalize (thread, 0B);
    threads_to_finalize.7 = threads_to_finalize;
    D.19251 = mono_mlist_next (threads_to_finalize.7);
    threads_to_finalize = D.19251;
  }
  <D.18812>:
  threads_to_finalize.7 = threads_to_finalize;
  if (threads_to_finalize.7 != 0B) goto <D.18811>; else goto <D.18813>;
  <D.18813>:
}


mono_gc_out_of_memory (size_t size)
{
  struct MonoDomain * D.19252;
  struct MonoException * D.19253;
  void * D.19254;

  D.19252 = mono_domain_get ();
  D.19253 = D.19252->out_of_memory_ex;
  mono_raise_exception (D.19253);
  D.19254 = 0B;
  return D.19254;
}


__attribute__((visibility ("hidden")))
mono_object_register_finalizer (struct MonoObject * obj)
{
  object_register_finalizer (obj, mono_gc_run_finalize);
}


mono_domain_finalize (struct MonoDomain * domain, guint32 timeout)
{
  struct MonoInternalThread * D.19256;
  struct MonoInternalThread * gc_thread.8;
  mono_bool D.19260;
  int gc_disabled.9;
  int D.19264;
  struct MonoDomain * D.19267;
  _Bool D.19272;
  long int D.19273;
  long int D.19274;
  struct GSList * domains_to_finalize.10;
  struct GSList * D.19278;
  _Bool D.19281;
  long int D.19282;
  long int D.19283;
  unsigned int D.19290;
  unsigned int D.19291;
  struct MonoDomain * D.19296;
  struct DomainFinalizationReq * req;
  guint32 res;
  void * done_event;
  struct MonoInternalThread * thread;

  thread = mono_thread_internal_current ();
  D.19256 = mono_thread_internal_current ();
  gc_thread.8 = gc_thread;
  if (D.19256 == gc_thread.8) goto <D.19258>; else goto <D.19259>;
  <D.19258>:
  D.19260 = 0;
  return D.19260;
  <D.19259>:
  gc_disabled.9 = gc_disabled;
  if (gc_disabled.9 != 0) goto <D.19262>; else goto <D.19263>;
  <D.19262>:
  D.19260 = 1;
  return D.19260;
  <D.19263>:
  D.19264 = mono_gc_max_generation ();
  mono_gc_collect (D.19264);
  done_event = CreateEvent (0B, 1, 0, 0B);
  if (done_event == 0B) goto <D.19265>; else goto <D.19266>;
  <D.19265>:
  D.19260 = 0;
  return D.19260;
  <D.19266>:
  req = monoeg_malloc0 (16);
  req->domain = domain;
  req->done_event = done_event;
  D.19267 = mono_get_root_domain ();
  if (D.19267 == domain) goto <D.19268>; else goto <D.19269>;
  <D.19268>:
  finalizing_root_domain = 1;
  <D.19269>:
  {
    int ret;

    ret = pthread_mutex_lock (&finalizer_mutex.mutex);
    if (ret != 0) goto <D.19270>; else goto <D.19271>;
    <D.19270>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
    <D.19271>:
    D.19272 = ret != 0;
    D.19273 = (long int) D.19272;
    D.19274 = __builtin_expect (D.19273, 0);
    if (D.19274 != 0) goto <D.19275>; else goto <D.19276>;
    <D.19275>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "gc.c", 367, "ret == 0");
    <D.19276>:
  }
  domains_to_finalize.10 = domains_to_finalize;
  D.19278 = monoeg_g_slist_append (domains_to_finalize.10, req);
  domains_to_finalize = D.19278;
  {
    int ret;

    ret = pthread_mutex_unlock (&finalizer_mutex.mutex);
    if (ret != 0) goto <D.19279>; else goto <D.19280>;
    <D.19279>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.19280>:
    D.19281 = ret != 0;
    D.19282 = (long int) D.19281;
    D.19283 = __builtin_expect (D.19282, 0);
    if (D.19283 != 0) goto <D.19284>; else goto <D.19285>;
    <D.19284>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "gc.c", 371, "ret == 0");
    <D.19285>:
  }
  mono_gc_finalize_notify ();
  if (timeout == 4294967295) goto <D.19286>; else goto <D.19287>;
  <D.19286>:
  timeout = 4294967295;
  <D.19287>:
  <D.18838>:
  res = WaitForSingleObjectEx (done_event, timeout, 1);
  if (res == 192) goto <D.19288>; else goto <D.19289>;
  <D.19288>:
  D.19290 = thread->state;
  D.19291 = D.19290 & 3;
  if (D.19291 != 0) goto <D.19292>; else goto <D.19293>;
  <D.19292>:
  D.19260 = 0;
  return D.19260;
  <D.19293>:
  goto <D.19294>;
  <D.19289>:
  if (res == 258) goto <D.19295>; else goto <D.18837>;
  <D.19295>:
  D.19260 = 0;
  return D.19260;
  <D.19294>:
  goto <D.18838>;
  <D.18837>:
  CloseHandle (done_event);
  D.19296 = mono_get_root_domain ();
  if (D.19296 == domain) goto <D.19297>; else goto <D.19298>;
  <D.19297>:
  mono_thread_pool_cleanup ();
  mono_gc_finalize_threadpool_threads ();
  <D.19298>:
  D.19260 = 1;
  return D.19260;
}


__attribute__((visibility ("hidden")))
ves_icall_System_GC_InternalCollect (int generation)
{
  mono_gc_collect (generation);
}


__attribute__((visibility ("hidden")))
ves_icall_System_GC_GetTotalMemory (MonoBoolean forceCollection)
{
  int D.19302;
  gint64 D.19303;

  if (forceCollection != 0) goto <D.19300>; else goto <D.19301>;
  <D.19300>:
  D.19302 = mono_gc_max_generation ();
  mono_gc_collect (D.19302);
  <D.19301>:
  D.19303 = mono_gc_get_used_size ();
  return D.19303;
}


__attribute__((visibility ("hidden")))
ves_icall_System_GC_KeepAlive (struct MonoObject * obj)
{

}


__attribute__((visibility ("hidden")))
ves_icall_System_GC_ReRegisterForFinalize (struct MonoObject * obj)
{
  struct MonoException * D.19307;

  if (obj == 0B) goto <D.19305>; else goto <D.19306>;
  <D.19305>:
  D.19307 = mono_get_exception_argument_null ("obj");
  mono_raise_exception (D.19307);
  <D.19306>:
  object_register_finalizer (obj, mono_gc_run_finalize);
}


__attribute__((visibility ("hidden")))
ves_icall_System_GC_SuppressFinalize (struct MonoObject * obj)
{
  struct MonoException * D.19310;
  struct MonoVTable * D.19311;
  struct MonoClass * D.19312;
  long unsigned int D.19313;
  long unsigned int D.19314;

  if (obj == 0B) goto <D.19308>; else goto <D.19309>;
  <D.19308>:
  D.19310 = mono_get_exception_argument_null ("obj");
  mono_raise_exception (D.19310);
  <D.19309>:
  D.19311 = obj->vtable;
  D.19312 = D.19311->klass;
  D.19313 = BIT_FIELD_REF <*D.19312, 64, 256>;
  D.19314 = D.19313 & 549755813888;
  if (D.19314 != 0) goto <D.19315>; else goto <D.19316>;
  <D.19315>:
  return;
  <D.19316>:
  object_register_finalizer (obj, 0B);
}


__attribute__((visibility ("hidden")))
ves_icall_System_GC_WaitForPendingFinalizers ()
{
  int D.19318;
  struct MonoInternalThread * D.19321;
  struct MonoInternalThread * gc_thread.11;
  void * pending_done_event.12;

  D.19318 = mono_gc_pending_finalizers ();
  if (D.19318 == 0) goto <D.19319>; else goto <D.19320>;
  <D.19319>:
  return;
  <D.19320>:
  D.19321 = mono_thread_internal_current ();
  gc_thread.11 = gc_thread;
  if (D.19321 == gc_thread.11) goto <D.19323>; else goto <D.19324>;
  <D.19323>:
  return;
  <D.19324>:
  gc_thread.11 = gc_thread;
  if (gc_thread.11 == 0B) goto <D.19325>; else goto <D.19326>;
  <D.19325>:
  return;
  <D.19326>:
  pending_done_event.12 = pending_done_event;
  ResetEvent (pending_done_event.12);
  mono_gc_finalize_notify ();
  pending_done_event.12 = pending_done_event;
  WaitForSingleObjectEx (pending_done_event.12, 4294967295, 1);
}


__attribute__((visibility ("hidden")))
ves_icall_System_GC_register_ephemeron_array (struct MonoObject * array)
{
  int D.19329;
  struct MonoVTable * D.19332;
  struct MonoDomain * D.19333;
  struct MonoException * D.19334;

  D.19329 = mono_gc_ephemeron_array_add (array);
  if (D.19329 == 0) goto <D.19330>; else goto <D.19331>;
  <D.19330>:
  D.19332 = array->vtable;
  D.19333 = D.19332->domain;
  D.19334 = D.19333->out_of_memory_ex;
  mono_raise_exception (D.19334);
  <D.19331>:
}


__attribute__((visibility ("hidden")))
ves_icall_System_GC_get_ephemeron_tombstone ()
{
  struct MonoObject * D.19335;
  struct MonoDomain * D.19336;

  D.19336 = mono_domain_get ();
  D.19335 = D.19336->ephemeron_tombstone;
  return D.19335;
}


__attribute__((visibility ("hidden")))
ves_icall_System_GCHandle_GetTarget (guint32 handle)
{
  struct MonoObject * D.19338;

  D.19338 = mono_gchandle_get_target (handle);
  return D.19338;
}


__attribute__((visibility ("hidden")))
ves_icall_System_GCHandle_GetTargetHandle (struct MonoObject * obj, guint32 handle, gint32 type)
{
  guint32 D.19342;

  if (type == -1) goto <D.19340>; else goto <D.19341>;
  <D.19340>:
  mono_gchandle_set_target (handle, obj);
  D.19342 = handle;
  return D.19342;
  <D.19341>:
  switch (type) <default: <D.18885>, case 0: <D.18881>, case 1: <D.18882>, case 2: <D.18883>, case 3: <D.18884>>
  <D.18881>:
  D.19342 = mono_gchandle_new_weakref (obj, 0);
  return D.19342;
  <D.18882>:
  D.19342 = mono_gchandle_new_weakref (obj, 1);
  return D.19342;
  <D.18883>:
  D.19342 = mono_gchandle_new (obj, 0);
  return D.19342;
  <D.18884>:
  D.19342 = mono_gchandle_new (obj, 1);
  return D.19342;
  <D.18885>:
  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "gc.c", 545);
  D.19342 = 0;
  return D.19342;
}


mono_gchandle_set_target (guint32 gchandle, struct MonoObject * obj)
{
  unsigned int D.19344;
  _Bool D.19349;
  long int D.19350;
  long int D.19351;
  unsigned int D.19354;
  guint32 * D.19357;
  unsigned int D.19358;
  long unsigned int D.19359;
  long unsigned int D.19360;
  guint32 * D.19361;
  unsigned int D.19362;
  unsigned int D.19363;
  int D.19364;
  unsigned int D.19365;
  unsigned int D.19366;
  unsigned char D.19369;
  void * * D.19372;
  long unsigned int D.19373;
  long unsigned int D.19374;
  void * * D.19375;
  void * D.19376;
  _Bool D.19379;
  int D.19380;
  guint16 * D.19383;
  long unsigned int D.19384;
  guint16 * D.19385;
  struct MonoDomain * iftmp.13;
  int D.19390;
  short unsigned int D.19391;
  _Bool D.19396;
  long int D.19397;
  long int D.19398;
  guint slot;
  guint type;
  struct HandleData * handles;
  struct MonoObject * old_obj;

  slot = gchandle >> 3;
  D.19344 = gchandle & 7;
  type = D.19344 + 4294967295;
  handles = &gc_handles[type];
  old_obj = 0B;
  if (type > 3) goto <D.19345>; else goto <D.19346>;
  <D.19345>:
  return;
  <D.19346>:
  {
    int ret;

    ret = pthread_mutex_lock (&handle_section.mutex);
    if (ret != 0) goto <D.19347>; else goto <D.19348>;
    <D.19347>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
    <D.19348>:
    D.19349 = ret != 0;
    D.19350 = (long int) D.19349;
    D.19351 = __builtin_expect (D.19350, 0);
    if (D.19351 != 0) goto <D.19352>; else goto <D.19353>;
    <D.19352>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "gc.c", 834, "ret == 0");
    <D.19353>:
  }
  D.19354 = handles->size;
  if (D.19354 > slot) goto <D.19355>; else goto <D.19356>;
  <D.19355>:
  D.19357 = handles->bitmap;
  D.19358 = slot / 32;
  D.19359 = (long unsigned int) D.19358;
  D.19360 = D.19359 * 4;
  D.19361 = D.19357 + D.19360;
  D.19362 = *D.19361;
  D.19363 = slot & 31;
  D.19364 = 1 << D.19363;
  D.19365 = (unsigned int) D.19364;
  D.19366 = D.19362 & D.19365;
  if (D.19366 != 0) goto <D.19367>; else goto <D.19368>;
  <D.19367>:
  D.19369 = handles->type;
  if (D.19369 <= 1) goto <D.19370>; else goto <D.19371>;
  <D.19370>:
  D.19372 = handles->entries;
  D.19373 = (long unsigned int) slot;
  D.19374 = D.19373 * 8;
  D.19375 = D.19372 + D.19374;
  old_obj = *D.19375;
  D.19372 = handles->entries;
  D.19373 = (long unsigned int) slot;
  D.19374 = D.19373 * 8;
  D.19375 = D.19372 + D.19374;
  D.19376 = *D.19375;
  if (D.19376 != 0B) goto <D.19377>; else goto <D.19378>;
  <D.19377>:
  D.19372 = handles->entries;
  D.19373 = (long unsigned int) slot;
  D.19374 = D.19373 * 8;
  D.19375 = D.19372 + D.19374;
  D.19369 = handles->type;
  D.19379 = D.19369 == 1;
  D.19380 = (int) D.19379;
  mono_gc_weak_link_remove (D.19375, D.19380);
  <D.19378>:
  if (obj != 0B) goto <D.19381>; else goto <D.19382>;
  <D.19381>:
  D.19372 = handles->entries;
  D.19373 = (long unsigned int) slot;
  D.19374 = D.19373 * 8;
  D.19375 = D.19372 + D.19374;
  D.19369 = handles->type;
  D.19379 = D.19369 == 1;
  D.19380 = (int) D.19379;
  mono_gc_weak_link_add (D.19375, obj, D.19380);
  <D.19382>:
  D.19383 = handles->domain_ids;
  D.19373 = (long unsigned int) slot;
  D.19384 = D.19373 * 2;
  D.19385 = D.19383 + D.19384;
  if (obj != 0B) goto <D.19387>; else goto <D.19388>;
  <D.19387>:
  iftmp.13 = mono_object_get_domain (obj);
  goto <D.19389>;
  <D.19388>:
  iftmp.13 = mono_domain_get ();
  <D.19389>:
  D.19390 = iftmp.13->domain_id;
  D.19391 = (short unsigned int) D.19390;
  *D.19385 = D.19391;
  goto <D.19392>;
  <D.19371>:
  D.19372 = handles->entries;
  D.19373 = (long unsigned int) slot;
  D.19374 = D.19373 * 8;
  D.19375 = D.19372 + D.19374;
  *D.19375 = obj;
  <D.19392>:
  goto <D.19393>;
  <D.19368>:
  <D.19393>:
  <D.19356>:
  {
    int ret;

    ret = pthread_mutex_unlock (&handle_section.mutex);
    if (ret != 0) goto <D.19394>; else goto <D.19395>;
    <D.19394>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.19395>:
    D.19396 = ret != 0;
    D.19397 = (long int) D.19396;
    D.19398 = __builtin_expect (D.19397, 0);
    if (D.19398 != 0) goto <D.19399>; else goto <D.19400>;
    <D.19399>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "gc.c", 851, "ret == 0");
    <D.19400>:
  }
}


__attribute__((visibility ("hidden")))
ves_icall_System_GCHandle_FreeHandle (guint32 handle)
{
  mono_gchandle_free (handle);
}


__attribute__((visibility ("hidden")))
ves_icall_System_GCHandle_GetAddrOfPinnedObject (guint32 handle)
{
  <unnamed type> D.19402;
  void * D.19405;
  struct MonoVTable * D.19408;
  struct MonoClass * D.19409;
  unsigned char D.19412;
  unsigned int D.19415;
  unsigned int D.19416;
  struct MonoObject * obj;

  D.19402 = mono_gchandle_get_type (handle);
  if (D.19402 != 3) goto <D.19403>; else goto <D.19404>;
  <D.19403>:
  D.19405 = -2B;
  return D.19405;
  <D.19404>:
  obj = mono_gchandle_get_target (handle);
  if (obj != 0B) goto <D.19406>; else goto <D.19407>;
  <D.19406>:
  {
    struct MonoClass * klass;

    D.19408 = obj->vtable;
    klass = D.19408->klass;
    D.19409 = mono_defaults.string_class;
    if (D.19409 == klass) goto <D.19410>; else goto <D.19411>;
    <D.19410>:
    D.19405 = mono_string_chars (obj);
    return D.19405;
    <D.19411>:
    D.19412 = klass->rank;
    if (D.19412 != 0) goto <D.19413>; else goto <D.19414>;
    <D.19413>:
    D.19405 = mono_array_addr_with_size (obj, 1, 0);
    return D.19405;
    <D.19414>:
    D.19415 = klass->flags;
    D.19416 = D.19415 & 24;
    if (D.19416 == 0) goto <D.19417>; else goto <D.19418>;
    <D.19417>:
    D.19405 = -1B;
    return D.19405;
    <D.19418>:
    D.19405 = obj + 16;
    return D.19405;
  }
  <D.19407>:
  D.19405 = 0B;
  return D.19405;
}


mono_gchandle_get_type (guint32 gchandle)
{
  unsigned int D.19420;
  HandleType D.19421;
  guint type;

  D.19420 = gchandle & 7;
  type = D.19420 + 4294967295;
  D.19421 = type;
  return D.19421;
}


__attribute__((visibility ("hidden")))
ves_icall_Mono_Runtime_SetGCAllowSynchronousMajor (MonoBoolean flag)
{
  MonoBoolean D.19423;
  int D.19424;
  int D.19425;

  D.19424 = (int) flag;
  D.19425 = mono_gc_set_allow_synchronous_major (D.19424);
  D.19423 = (MonoBoolean) D.19425;
  return D.19423;
}


mono_gchandle_new (struct MonoObject * obj, gboolean pinned)
{
  uint32_t D.19427;
  int iftmp.14;
  struct HandleData * D.19432;

  if (pinned != 0) goto <D.19429>; else goto <D.19430>;
  <D.19429>:
  iftmp.14 = 3;
  goto <D.19431>;
  <D.19430>:
  iftmp.14 = 2;
  <D.19431>:
  D.19432 = &gc_handles[iftmp.14];
  D.19427 = alloc_handle (D.19432, obj, 0);
  return D.19427;
}


alloc_handle (struct HandleData * handles, struct MonoObject * obj, gboolean track)
{
  _Bool D.19436;
  long int D.19437;
  long int D.19438;
  unsigned int D.19441;
  unsigned char D.19444;
  long unsigned int D.19447;
  long unsigned int D.19448;
  int D.19449;
  _Bool D.19450;
  int D.19451;
  void * D.19452;
  void * D.19453;
  void * D.19455;
  long unsigned int D.19456;
  void * D.19457;
  unsigned int D.19458;
  long unsigned int D.19459;
  void * D.19460;
  <unnamed-unsigned:24> D.19461;
  guint32 * D.19462;
  long unsigned int D.19463;
  long unsigned int D.19464;
  guint32 * D.19465;
  unsigned int D.19466;
  unsigned int slot.15;
  <unnamed-unsigned:24> D.19470;
  unsigned int D.19471;
  unsigned int slot.16;
  long unsigned int D.19475;
  long unsigned int D.19476;
  int D.19481;
  unsigned int D.19484;
  long unsigned int D.19485;
  long unsigned int D.19486;
  long unsigned int D.19489;
  long unsigned int D.19490;
  int new_size.17;
  void * D.19492;
  void * * D.19493;
  long unsigned int D.19495;
  guint16 * D.19496;
  long unsigned int D.19497;
  long unsigned int D.19498;
  void * * D.19499;
  void * * D.19502;
  void * D.19504;
  _Bool D.19505;
  long int D.19506;
  long int D.19507;
  unsigned int i.18;
  unsigned int D.19511;
  unsigned int D.19512;
  <unnamed-unsigned:24> D.19513;
  int D.19514;
  unsigned int D.19515;
  unsigned int D.19516;
  int D.19517;
  long unsigned int D.19518;
  void * * D.19519;
  long unsigned int D.19522;
  guint16 * D.19523;
  struct MonoDomain * iftmp.19;
  int D.19528;
  short unsigned int D.19529;
  struct MonoPerfCounters * mono_perfcounters.20;
  unsigned int D.19534;
  unsigned int D.19535;
  _Bool D.19538;
  long int D.19539;
  long int D.19540;
  int D.19543;
  int D.19544;
  int D.19545;
  int D.19546;
  long unsigned int D.19547;
  guint32 D.19548;
  gint slot;
  gint i;
  guint32 res;

  {
    int ret;

    ret = pthread_mutex_lock (&handle_section.mutex);
    if (ret != 0) goto <D.19434>; else goto <D.19435>;
    <D.19434>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
    <D.19435>:
    D.19436 = ret != 0;
    D.19437 = (long int) D.19436;
    D.19438 = __builtin_expect (D.19437, 0);
    if (D.19438 != 0) goto <D.19439>; else goto <D.19440>;
    <D.19439>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "gc.c", 636, "ret == 0");
    <D.19440>:
  }
  D.19441 = handles->size;
  if (D.19441 == 0) goto <D.19442>; else goto <D.19443>;
  <D.19442>:
  handles->size = 32;
  D.19444 = handles->type;
  if (D.19444 > 1) goto <D.19445>; else goto <D.19446>;
  <D.19445>:
  D.19441 = handles->size;
  D.19447 = (long unsigned int) D.19441;
  D.19448 = D.19447 * 8;
  D.19441 = handles->size;
  D.19449 = (int) D.19441;
  D.19444 = handles->type;
  D.19450 = D.19444 == 3;
  D.19451 = (int) D.19450;
  D.19452 = make_root_descr_all_refs (D.19449, D.19451);
  D.19453 = mono_gc_alloc_fixed (D.19448, D.19452);
  handles->entries = D.19453;
  goto <D.19454>;
  <D.19446>:
  D.19441 = handles->size;
  D.19447 = (long unsigned int) D.19441;
  D.19448 = D.19447 * 8;
  D.19455 = monoeg_malloc0 (D.19448);
  handles->entries = D.19455;
  D.19441 = handles->size;
  D.19447 = (long unsigned int) D.19441;
  D.19456 = D.19447 * 2;
  D.19457 = monoeg_malloc0 (D.19456);
  handles->domain_ids = D.19457;
  <D.19454>:
  D.19441 = handles->size;
  D.19458 = D.19441 / 8;
  D.19459 = (long unsigned int) D.19458;
  D.19460 = monoeg_malloc0 (D.19459);
  handles->bitmap = D.19460;
  <D.19443>:
  i = -1;
  D.19461 = handles->slot_hint;
  slot = (gint) D.19461;
  goto <D.18929>;
  <D.18928>:
  D.19462 = handles->bitmap;
  D.19463 = (long unsigned int) slot;
  D.19464 = D.19463 * 4;
  D.19465 = D.19462 + D.19464;
  D.19466 = *D.19465;
  if (D.19466 != 4294967295) goto <D.19467>; else goto <D.19468>;
  <D.19467>:
  D.19462 = handles->bitmap;
  D.19463 = (long unsigned int) slot;
  D.19464 = D.19463 * 4;
  D.19465 = D.19462 + D.19464;
  D.19466 = *D.19465;
  i = find_first_unset (D.19466);
  slot.15 = (unsigned int) slot;
  D.19470 = (<unnamed-unsigned:24>) slot.15;
  handles->slot_hint = D.19470;
  goto <D.18927>;
  <D.19468>:
  slot = slot + 1;
  <D.18929>:
  D.19441 = handles->size;
  D.19471 = D.19441 / 32;
  slot.16 = (unsigned int) slot;
  if (D.19471 > slot.16) goto <D.18928>; else goto <D.18927>;
  <D.18927>:
  if (i == -1) goto <D.19473>; else goto <D.19474>;
  <D.19473>:
  D.19475 = BIT_FIELD_REF <*handles, 64, 128>;
  D.19476 = D.19475 & 16777215;
  if (D.19476 != 0) goto <D.19477>; else goto <D.19478>;
  <D.19477>:
  slot = 0;
  goto <D.18932>;
  <D.18931>:
  D.19462 = handles->bitmap;
  D.19463 = (long unsigned int) slot;
  D.19464 = D.19463 * 4;
  D.19465 = D.19462 + D.19464;
  D.19466 = *D.19465;
  if (D.19466 != 4294967295) goto <D.19479>; else goto <D.19480>;
  <D.19479>:
  D.19462 = handles->bitmap;
  D.19463 = (long unsigned int) slot;
  D.19464 = D.19463 * 4;
  D.19465 = D.19462 + D.19464;
  D.19466 = *D.19465;
  i = find_first_unset (D.19466);
  slot.15 = (unsigned int) slot;
  D.19470 = (<unnamed-unsigned:24>) slot.15;
  handles->slot_hint = D.19470;
  goto <D.18930>;
  <D.19480>:
  slot = slot + 1;
  <D.18932>:
  D.19461 = handles->slot_hint;
  D.19481 = (int) D.19461;
  if (D.19481 > slot) goto <D.18931>; else goto <D.18930>;
  <D.18930>:
  <D.19478>:
  <D.19474>:
  if (i == -1) goto <D.19482>; else goto <D.19483>;
  <D.19482>:
  {
    guint32 * new_bitmap;
    guint32 new_size;

    D.19441 = handles->size;
    new_size = D.19441 * 2;
    D.19484 = new_size / 8;
    D.19485 = (long unsigned int) D.19484;
    new_bitmap = monoeg_malloc0 (D.19485);
    D.19462 = handles->bitmap;
    D.19441 = handles->size;
    D.19458 = D.19441 / 8;
    D.19486 = (long unsigned int) D.19458;
    memcpy (new_bitmap, D.19462, D.19486);
    D.19462 = handles->bitmap;
    monoeg_g_free (D.19462);
    handles->bitmap = new_bitmap;
    D.19444 = handles->type;
    if (D.19444 > 1) goto <D.19487>; else goto <D.19488>;
    <D.19487>:
    {
      void * * entries;

      D.19489 = (long unsigned int) new_size;
      D.19490 = D.19489 * 8;
      new_size.17 = (int) new_size;
      D.19444 = handles->type;
      D.19450 = D.19444 == 3;
      D.19451 = (int) D.19450;
      D.19492 = make_root_descr_all_refs (new_size.17, D.19451);
      entries = mono_gc_alloc_fixed (D.19490, D.19492);
      D.19493 = handles->entries;
      D.19441 = handles->size;
      D.19447 = (long unsigned int) D.19441;
      D.19448 = D.19447 * 8;
      mono_gc_memmove_aligned (entries, D.19493, D.19448);
      D.19493 = handles->entries;
      mono_gc_free_fixed (D.19493);
      handles->entries = entries;
    }
    goto <D.19494>;
    <D.19488>:
    {
      void * * entries;
      guint16 * domain_ids;

      D.19489 = (long unsigned int) new_size;
      D.19495 = D.19489 * 2;
      domain_ids = monoeg_malloc0 (D.19495);
      D.19489 = (long unsigned int) new_size;
      D.19490 = D.19489 * 8;
      entries = monoeg_malloc0 (D.19490);
      D.19496 = handles->domain_ids;
      D.19441 = handles->size;
      D.19447 = (long unsigned int) D.19441;
      D.19456 = D.19447 * 2;
      memcpy (domain_ids, D.19496, D.19456);
      i = 0;
      goto <D.18940>;
      <D.18939>:
      {
        struct MonoObject * obj;

        D.19493 = handles->entries;
        D.19497 = (long unsigned int) i;
        D.19498 = D.19497 * 8;
        D.19499 = D.19493 + D.19498;
        obj = mono_gc_weak_link_get (D.19499);
        if (obj != 0B) goto <D.19500>; else goto <D.19501>;
        <D.19500>:
        D.19497 = (long unsigned int) i;
        D.19498 = D.19497 * 8;
        D.19502 = entries + D.19498;
        mono_gc_weak_link_add (D.19502, obj, track);
        D.19493 = handles->entries;
        D.19497 = (long unsigned int) i;
        D.19498 = D.19497 * 8;
        D.19499 = D.19493 + D.19498;
        mono_gc_weak_link_remove (D.19499, track);
        goto <D.19503>;
        <D.19501>:
        D.19493 = handles->entries;
        D.19497 = (long unsigned int) i;
        D.19498 = D.19497 * 8;
        D.19499 = D.19493 + D.19498;
        D.19504 = *D.19499;
        D.19505 = D.19504 != 0B;
        D.19506 = (long int) D.19505;
        D.19507 = __builtin_expect (D.19506, 0);
        if (D.19507 != 0) goto <D.19508>; else goto <D.19509>;
        <D.19508>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "gc.c", 695, "!handles->entries [i]");
        <D.19509>:
        <D.19503>:
      }
      i = i + 1;
      <D.18940>:
      D.19441 = handles->size;
      i.18 = (unsigned int) i;
      if (D.19441 > i.18) goto <D.18939>; else goto <D.18941>;
      <D.18941>:
      D.19493 = handles->entries;
      monoeg_g_free (D.19493);
      D.19496 = handles->domain_ids;
      monoeg_g_free (D.19496);
      handles->entries = entries;
      handles->domain_ids = domain_ids;
    }
    <D.19494>:
    i = 0;
    D.19441 = handles->size;
    D.19511 = D.19441 + 1;
    D.19512 = D.19511 / 32;
    slot = (gint) D.19512;
    D.19441 = handles->size;
    D.19511 = D.19441 + 1;
    D.19513 = (<unnamed-unsigned:24>) D.19511;
    handles->slot_hint = D.19513;
    handles->size = new_size;
  }
  <D.19483>:
  D.19462 = handles->bitmap;
  D.19463 = (long unsigned int) slot;
  D.19464 = D.19463 * 4;
  D.19465 = D.19462 + D.19464;
  D.19462 = handles->bitmap;
  D.19463 = (long unsigned int) slot;
  D.19464 = D.19463 * 4;
  D.19465 = D.19462 + D.19464;
  D.19466 = *D.19465;
  D.19514 = 1 << i;
  D.19515 = (unsigned int) D.19514;
  D.19516 = D.19466 | D.19515;
  *D.19465 = D.19516;
  D.19517 = slot * 32;
  slot = D.19517 + i;
  D.19493 = handles->entries;
  D.19463 = (long unsigned int) slot;
  D.19518 = D.19463 * 8;
  D.19519 = D.19493 + D.19518;
  *D.19519 = 0B;
  D.19444 = handles->type;
  if (D.19444 <= 1) goto <D.19520>; else goto <D.19521>;
  <D.19520>:
  D.19496 = handles->domain_ids;
  D.19463 = (long unsigned int) slot;
  D.19522 = D.19463 * 2;
  D.19523 = D.19496 + D.19522;
  if (obj != 0B) goto <D.19525>; else goto <D.19526>;
  <D.19525>:
  iftmp.19 = mono_object_get_domain (obj);
  goto <D.19527>;
  <D.19526>:
  iftmp.19 = mono_domain_get ();
  <D.19527>:
  D.19528 = iftmp.19->domain_id;
  D.19529 = (short unsigned int) D.19528;
  *D.19523 = D.19529;
  if (obj != 0B) goto <D.19530>; else goto <D.19531>;
  <D.19530>:
  D.19493 = handles->entries;
  D.19463 = (long unsigned int) slot;
  D.19518 = D.19463 * 8;
  D.19519 = D.19493 + D.19518;
  mono_gc_weak_link_add (D.19519, obj, track);
  <D.19531>:
  goto <D.19532>;
  <D.19521>:
  D.19493 = handles->entries;
  D.19463 = (long unsigned int) slot;
  D.19518 = D.19463 * 8;
  D.19519 = D.19493 + D.19518;
  *D.19519 = obj;
  <D.19532>:
  mono_perfcounters.20 = mono_perfcounters;
  D.19534 = mono_perfcounters.20->gc_num_handles;
  D.19535 = D.19534 + 1;
  mono_perfcounters.20->gc_num_handles = D.19535;
  {
    int ret;

    ret = pthread_mutex_unlock (&handle_section.mutex);
    if (ret != 0) goto <D.19536>; else goto <D.19537>;
    <D.19536>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.19537>:
    D.19538 = ret != 0;
    D.19539 = (long int) D.19538;
    D.19540 = __builtin_expect (D.19539, 0);
    if (D.19540 != 0) goto <D.19541>; else goto <D.19542>;
    <D.19541>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "gc.c", 725, "ret == 0");
    <D.19542>:
  }
  D.19543 = slot << 3;
  D.19444 = handles->type;
  D.19544 = (int) D.19444;
  D.19545 = D.19544 + 1;
  D.19546 = D.19543 | D.19545;
  res = (guint32) D.19546;
  D.19444 = handles->type;
  D.19544 = (int) D.19444;
  D.19547 = (long unsigned int) res;
  mono_profiler_gc_handle (0, D.19544, D.19547, obj);
  D.19548 = res;
  return D.19548;
}


find_first_unset (guint32 bitmap)
{
  int D.19550;
  unsigned int D.19551;
  unsigned int D.19552;
  int D.19555;
  int i;

  i = 0;
  goto <D.18912>;
  <D.18911>:
  D.19550 = 1 << i;
  D.19551 = (unsigned int) D.19550;
  D.19552 = D.19551 & bitmap;
  if (D.19552 == 0) goto <D.19553>; else goto <D.19554>;
  <D.19553>:
  D.19555 = i;
  return D.19555;
  <D.19554>:
  i = i + 1;
  <D.18912>:
  if (i <= 31) goto <D.18911>; else goto <D.18913>;
  <D.18913>:
  D.19555 = -1;
  return D.19555;
}


make_root_descr_all_refs (int numbits, gboolean pinned)
{
  void * D.19559;

  if (pinned != 0) goto <D.19557>; else goto <D.19558>;
  <D.19557>:
  D.19559 = 0B;
  return D.19559;
  <D.19558>:
  D.19559 = mono_gc_make_root_descr_all_refs (numbits);
  return D.19559;
}


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

  D.19562 = __builtin_object_size (__dest, 0);
  D.19561 = __builtin___memcpy_chk (__dest, __src, __len, D.19562);
  return D.19561;
}


mono_gchandle_new_weakref (struct MonoObject * obj, gboolean track_resurrection)
{
  _Bool D.19564;
  int D.19565;
  struct HandleData * D.19566;
  uint32_t D.19567;
  guint32 handle;

  D.19564 = track_resurrection != 0;
  D.19565 = (int) D.19564;
  D.19566 = &gc_handles[D.19565];
  handle = alloc_handle (D.19566, obj, track_resurrection);
  D.19567 = handle;
  return D.19567;
}


mono_gchandle_get_target (guint32 gchandle)
{
  unsigned int D.19569;
  struct MonoObject * D.19572;
  _Bool D.19575;
  long int D.19576;
  long int D.19577;
  unsigned int D.19580;
  guint32 * D.19583;
  unsigned int D.19584;
  long unsigned int D.19585;
  long unsigned int D.19586;
  guint32 * D.19587;
  unsigned int D.19588;
  unsigned int D.19589;
  int D.19590;
  unsigned int D.19591;
  unsigned int D.19592;
  unsigned char D.19595;
  void * * D.19598;
  long unsigned int D.19599;
  long unsigned int D.19600;
  void * * D.19601;
  _Bool D.19606;
  long int D.19607;
  long int D.19608;
  guint slot;
  guint type;
  struct HandleData * handles;
  struct MonoObject * obj;

  slot = gchandle >> 3;
  D.19569 = gchandle & 7;
  type = D.19569 + 4294967295;
  handles = &gc_handles[type];
  obj = 0B;
  if (type > 3) goto <D.19570>; else goto <D.19571>;
  <D.19570>:
  D.19572 = 0B;
  return D.19572;
  <D.19571>:
  {
    int ret;

    ret = pthread_mutex_lock (&handle_section.mutex);
    if (ret != 0) goto <D.19573>; else goto <D.19574>;
    <D.19573>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
    <D.19574>:
    D.19575 = ret != 0;
    D.19576 = (long int) D.19575;
    D.19577 = __builtin_expect (D.19576, 0);
    if (D.19577 != 0) goto <D.19578>; else goto <D.19579>;
    <D.19578>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "gc.c", 809, "ret == 0");
    <D.19579>:
  }
  D.19580 = handles->size;
  if (D.19580 > slot) goto <D.19581>; else goto <D.19582>;
  <D.19581>:
  D.19583 = handles->bitmap;
  D.19584 = slot / 32;
  D.19585 = (long unsigned int) D.19584;
  D.19586 = D.19585 * 4;
  D.19587 = D.19583 + D.19586;
  D.19588 = *D.19587;
  D.19589 = slot & 31;
  D.19590 = 1 << D.19589;
  D.19591 = (unsigned int) D.19590;
  D.19592 = D.19588 & D.19591;
  if (D.19592 != 0) goto <D.19593>; else goto <D.19594>;
  <D.19593>:
  D.19595 = handles->type;
  if (D.19595 <= 1) goto <D.19596>; else goto <D.19597>;
  <D.19596>:
  D.19598 = handles->entries;
  D.19599 = (long unsigned int) slot;
  D.19600 = D.19599 * 8;
  D.19601 = D.19598 + D.19600;
  obj = mono_gc_weak_link_get (D.19601);
  goto <D.19602>;
  <D.19597>:
  D.19598 = handles->entries;
  D.19599 = (long unsigned int) slot;
  D.19600 = D.19599 * 8;
  D.19601 = D.19598 + D.19600;
  obj = *D.19601;
  <D.19602>:
  goto <D.19603>;
  <D.19594>:
  <D.19603>:
  <D.19582>:
  {
    int ret;

    ret = pthread_mutex_unlock (&handle_section.mutex);
    if (ret != 0) goto <D.19604>; else goto <D.19605>;
    <D.19604>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.19605>:
    D.19606 = ret != 0;
    D.19607 = (long int) D.19606;
    D.19608 = __builtin_expect (D.19607, 0);
    if (D.19608 != 0) goto <D.19609>; else goto <D.19610>;
    <D.19609>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "gc.c", 819, "ret == 0");
    <D.19610>:
  }
  D.19572 = obj;
  return D.19572;
}


__attribute__((visibility ("hidden")))
mono_gchandle_is_in_domain (guint32 gchandle, struct MonoDomain * domain)
{
  unsigned int D.19612;
  gboolean D.19615;
  _Bool D.19618;
  long int D.19619;
  long int D.19620;
  unsigned int D.19623;
  guint32 * D.19626;
  unsigned int D.19627;
  long unsigned int D.19628;
  long unsigned int D.19629;
  guint32 * D.19630;
  unsigned int D.19631;
  unsigned int D.19632;
  int D.19633;
  unsigned int D.19634;
  unsigned int D.19635;
  unsigned char D.19638;
  int D.19641;
  guint16 * D.19642;
  long unsigned int D.19643;
  long unsigned int D.19644;
  guint16 * D.19645;
  short unsigned int D.19646;
  int D.19647;
  _Bool D.19648;
  void * * D.19650;
  long unsigned int D.19651;
  void * * D.19652;
  struct MonoVTable * D.19656;
  struct MonoDomain * D.19657;
  _Bool D.19658;
  _Bool D.19662;
  long int D.19663;
  long int D.19664;
  guint slot;
  guint type;
  struct HandleData * handles;
  gboolean result;

  slot = gchandle >> 3;
  D.19612 = gchandle & 7;
  type = D.19612 + 4294967295;
  handles = &gc_handles[type];
  result = 0;
  if (type > 3) goto <D.19613>; else goto <D.19614>;
  <D.19613>:
  D.19615 = 0;
  return D.19615;
  <D.19614>:
  {
    int ret;

    ret = pthread_mutex_lock (&handle_section.mutex);
    if (ret != 0) goto <D.19616>; else goto <D.19617>;
    <D.19616>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
    <D.19617>:
    D.19618 = ret != 0;
    D.19619 = (long int) D.19618;
    D.19620 = __builtin_expect (D.19619, 0);
    if (D.19620 != 0) goto <D.19621>; else goto <D.19622>;
    <D.19621>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "gc.c", 870, "ret == 0");
    <D.19622>:
  }
  D.19623 = handles->size;
  if (D.19623 > slot) goto <D.19624>; else goto <D.19625>;
  <D.19624>:
  D.19626 = handles->bitmap;
  D.19627 = slot / 32;
  D.19628 = (long unsigned int) D.19627;
  D.19629 = D.19628 * 4;
  D.19630 = D.19626 + D.19629;
  D.19631 = *D.19630;
  D.19632 = slot & 31;
  D.19633 = 1 << D.19632;
  D.19634 = (unsigned int) D.19633;
  D.19635 = D.19631 & D.19634;
  if (D.19635 != 0) goto <D.19636>; else goto <D.19637>;
  <D.19636>:
  D.19638 = handles->type;
  if (D.19638 <= 1) goto <D.19639>; else goto <D.19640>;
  <D.19639>:
  D.19641 = domain->domain_id;
  D.19642 = handles->domain_ids;
  D.19643 = (long unsigned int) slot;
  D.19644 = D.19643 * 2;
  D.19645 = D.19642 + D.19644;
  D.19646 = *D.19645;
  D.19647 = (int) D.19646;
  D.19648 = D.19641 == D.19647;
  result = (gboolean) D.19648;
  goto <D.19649>;
  <D.19640>:
  {
    struct MonoObject * obj;

    D.19650 = handles->entries;
    D.19643 = (long unsigned int) slot;
    D.19651 = D.19643 * 8;
    D.19652 = D.19650 + D.19651;
    obj = *D.19652;
    if (obj == 0B) goto <D.19653>; else goto <D.19654>;
    <D.19653>:
    result = 1;
    goto <D.19655>;
    <D.19654>:
    D.19656 = obj->vtable;
    D.19657 = D.19656->domain;
    D.19658 = D.19657 == domain;
    result = (gboolean) D.19658;
    <D.19655>:
  }
  <D.19649>:
  goto <D.19659>;
  <D.19637>:
  <D.19659>:
  <D.19625>:
  {
    int ret;

    ret = pthread_mutex_unlock (&handle_section.mutex);
    if (ret != 0) goto <D.19660>; else goto <D.19661>;
    <D.19660>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.19661>:
    D.19662 = ret != 0;
    D.19663 = (long int) D.19662;
    D.19664 = __builtin_expect (D.19663, 0);
    if (D.19664 != 0) goto <D.19665>; else goto <D.19666>;
    <D.19665>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "gc.c", 885, "ret == 0");
    <D.19666>:
  }
  D.19615 = result;
  return D.19615;
}


mono_gchandle_free (guint32 gchandle)
{
  unsigned int D.19668;
  _Bool D.19673;
  long int D.19674;
  long int D.19675;
  unsigned int D.19678;
  guint32 * D.19681;
  unsigned int D.19682;
  long unsigned int D.19683;
  long unsigned int D.19684;
  guint32 * D.19685;
  unsigned int D.19686;
  unsigned int D.19687;
  int D.19688;
  unsigned int D.19689;
  unsigned int D.19690;
  unsigned char D.19693;
  void * * D.19696;
  long unsigned int D.19697;
  long unsigned int D.19698;
  void * * D.19699;
  void * D.19700;
  _Bool D.19703;
  int D.19704;
  unsigned int D.19706;
  long unsigned int D.19707;
  long unsigned int D.19708;
  guint32 * D.19709;
  unsigned int D.19710;
  int D.19711;
  unsigned int D.19712;
  unsigned int D.19713;
  struct MonoPerfCounters * mono_perfcounters.21;
  unsigned int D.19716;
  unsigned int D.19717;
  _Bool D.19720;
  long int D.19721;
  long int D.19722;
  int D.19725;
  long unsigned int D.19726;
  guint slot;
  guint type;
  struct HandleData * handles;

  slot = gchandle >> 3;
  D.19668 = gchandle & 7;
  type = D.19668 + 4294967295;
  handles = &gc_handles[type];
  if (type > 3) goto <D.19669>; else goto <D.19670>;
  <D.19669>:
  return;
  <D.19670>:
  {
    int ret;

    ret = pthread_mutex_lock (&handle_section.mutex);
    if (ret != 0) goto <D.19671>; else goto <D.19672>;
    <D.19671>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
    <D.19672>:
    D.19673 = ret != 0;
    D.19674 = (long int) D.19673;
    D.19675 = __builtin_expect (D.19674, 0);
    if (D.19675 != 0) goto <D.19676>; else goto <D.19677>;
    <D.19676>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "gc.c", 906, "ret == 0");
    <D.19677>:
  }
  D.19678 = handles->size;
  if (D.19678 > slot) goto <D.19679>; else goto <D.19680>;
  <D.19679>:
  D.19681 = handles->bitmap;
  D.19682 = slot / 32;
  D.19683 = (long unsigned int) D.19682;
  D.19684 = D.19683 * 4;
  D.19685 = D.19681 + D.19684;
  D.19686 = *D.19685;
  D.19687 = slot & 31;
  D.19688 = 1 << D.19687;
  D.19689 = (unsigned int) D.19688;
  D.19690 = D.19686 & D.19689;
  if (D.19690 != 0) goto <D.19691>; else goto <D.19692>;
  <D.19691>:
  D.19693 = handles->type;
  if (D.19693 <= 1) goto <D.19694>; else goto <D.19695>;
  <D.19694>:
  D.19696 = handles->entries;
  D.19697 = (long unsigned int) slot;
  D.19698 = D.19697 * 8;
  D.19699 = D.19696 + D.19698;
  D.19700 = *D.19699;
  if (D.19700 != 0B) goto <D.19701>; else goto <D.19702>;
  <D.19701>:
  D.19696 = handles->entries;
  D.19697 = (long unsigned int) slot;
  D.19698 = D.19697 * 8;
  D.19699 = D.19696 + D.19698;
  D.19693 = handles->type;
  D.19703 = D.19693 == 1;
  D.19704 = (int) D.19703;
  mono_gc_weak_link_remove (D.19699, D.19704);
  <D.19702>:
  goto <D.19705>;
  <D.19695>:
  D.19696 = handles->entries;
  D.19697 = (long unsigned int) slot;
  D.19698 = D.19697 * 8;
  D.19699 = D.19696 + D.19698;
  *D.19699 = 0B;
  <D.19705>:
  D.19681 = handles->bitmap;
  D.19706 = slot / 32;
  D.19707 = (long unsigned int) D.19706;
  D.19708 = D.19707 * 4;
  D.19709 = D.19681 + D.19708;
  D.19681 = handles->bitmap;
  D.19707 = (long unsigned int) D.19706;
  D.19708 = D.19707 * 4;
  D.19709 = D.19681 + D.19708;
  D.19710 = *D.19709;
  D.19687 = slot & 31;
  D.19688 = 1 << D.19687;
  D.19711 = ~D.19688;
  D.19712 = (unsigned int) D.19711;
  D.19713 = D.19710 & D.19712;
  *D.19709 = D.19713;
  goto <D.19714>;
  <D.19692>:
  <D.19714>:
  <D.19680>:
  mono_perfcounters.21 = mono_perfcounters;
  D.19716 = mono_perfcounters.21->gc_num_handles;
  D.19717 = D.19716 + 4294967295;
  mono_perfcounters.21->gc_num_handles = D.19717;
  {
    int ret;

    ret = pthread_mutex_unlock (&handle_section.mutex);
    if (ret != 0) goto <D.19718>; else goto <D.19719>;
    <D.19718>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.19719>:
    D.19720 = ret != 0;
    D.19721 = (long int) D.19720;
    D.19722 = __builtin_expect (D.19721, 0);
    if (D.19722 != 0) goto <D.19723>; else goto <D.19724>;
    <D.19723>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "gc.c", 922, "ret == 0");
    <D.19724>:
  }
  D.19693 = handles->type;
  D.19725 = (int) D.19693;
  D.19726 = (long unsigned int) gchandle;
  mono_profiler_gc_handle (1, D.19725, D.19726, 0B);
}


__attribute__((visibility ("hidden")))
mono_gchandle_free_domain (struct MonoDomain * domain)
{
  _Bool D.19730;
  long int D.19731;
  long int D.19732;
  guint32 * D.19735;
  unsigned int D.19736;
  long unsigned int D.19737;
  long unsigned int D.19738;
  guint32 * D.19739;
  unsigned int D.19740;
  unsigned int D.19741;
  int D.19742;
  unsigned int D.19743;
  unsigned int D.19744;
  int D.19749;
  guint16 * D.19750;
  long unsigned int D.19751;
  long unsigned int D.19752;
  guint16 * D.19753;
  short unsigned int D.19754;
  int D.19755;
  unsigned int D.19758;
  long unsigned int D.19759;
  long unsigned int D.19760;
  guint32 * D.19761;
  unsigned int D.19762;
  int D.19763;
  unsigned int D.19764;
  unsigned int D.19765;
  void * * D.19766;
  long unsigned int D.19767;
  void * * D.19768;
  void * D.19769;
  unsigned char D.19772;
  _Bool D.19773;
  int D.19774;
  struct MonoVTable * D.19778;
  struct MonoDomain * D.19779;
  unsigned int D.19782;
  long unsigned int D.19783;
  long unsigned int D.19784;
  guint32 * D.19785;
  unsigned int D.19786;
  unsigned int D.19787;
  unsigned int D.19788;
  _Bool D.19791;
  long int D.19792;
  long int D.19793;
  guint type;

  type = 0;
  goto <D.19007>;
  <D.19006>:
  {
    guint slot;
    struct HandleData * handles;

    handles = &gc_handles[type];
    {
      int ret;

      ret = pthread_mutex_lock (&handle_section.mutex);
      if (ret != 0) goto <D.19728>; else goto <D.19729>;
      <D.19728>:
      monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
      <D.19729>:
      D.19730 = ret != 0;
      D.19731 = (long int) D.19730;
      D.19732 = __builtin_expect (D.19731, 0);
      if (D.19732 != 0) goto <D.19733>; else goto <D.19734>;
      <D.19733>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "gc.c", 941, "ret == 0");
      <D.19734>:
    }
    slot = 0;
    goto <D.19003>;
    <D.19002>:
    D.19735 = handles->bitmap;
    D.19736 = slot / 32;
    D.19737 = (long unsigned int) D.19736;
    D.19738 = D.19737 * 4;
    D.19739 = D.19735 + D.19738;
    D.19740 = *D.19739;
    D.19741 = slot & 31;
    D.19742 = 1 << D.19741;
    D.19743 = (unsigned int) D.19742;
    D.19744 = D.19740 & D.19743;
    if (D.19744 == 0) goto <D.19745>; else goto <D.19746>;
    <D.19745>:
    // predicted unlikely by continue predictor.
    goto <D.19001>;
    <D.19746>:
    if (type <= 1) goto <D.19747>; else goto <D.19748>;
    <D.19747>:
    D.19749 = domain->domain_id;
    D.19750 = handles->domain_ids;
    D.19751 = (long unsigned int) slot;
    D.19752 = D.19751 * 2;
    D.19753 = D.19750 + D.19752;
    D.19754 = *D.19753;
    D.19755 = (int) D.19754;
    if (D.19749 == D.19755) goto <D.19756>; else goto <D.19757>;
    <D.19756>:
    D.19735 = handles->bitmap;
    D.19758 = slot / 32;
    D.19759 = (long unsigned int) D.19758;
    D.19760 = D.19759 * 4;
    D.19761 = D.19735 + D.19760;
    D.19735 = handles->bitmap;
    D.19759 = (long unsigned int) D.19758;
    D.19760 = D.19759 * 4;
    D.19761 = D.19735 + D.19760;
    D.19762 = *D.19761;
    D.19741 = slot & 31;
    D.19742 = 1 << D.19741;
    D.19763 = ~D.19742;
    D.19764 = (unsigned int) D.19763;
    D.19765 = D.19762 & D.19764;
    *D.19761 = D.19765;
    D.19766 = handles->entries;
    D.19751 = (long unsigned int) slot;
    D.19767 = D.19751 * 8;
    D.19768 = D.19766 + D.19767;
    D.19769 = *D.19768;
    if (D.19769 != 0B) goto <D.19770>; else goto <D.19771>;
    <D.19770>:
    D.19766 = handles->entries;
    D.19751 = (long unsigned int) slot;
    D.19767 = D.19751 * 8;
    D.19768 = D.19766 + D.19767;
    D.19772 = handles->type;
    D.19773 = D.19772 == 1;
    D.19774 = (int) D.19773;
    mono_gc_weak_link_remove (D.19768, D.19774);
    <D.19771>:
    <D.19757>:
    goto <D.19775>;
    <D.19748>:
    D.19766 = handles->entries;
    D.19751 = (long unsigned int) slot;
    D.19767 = D.19751 * 8;
    D.19768 = D.19766 + D.19767;
    D.19769 = *D.19768;
    if (D.19769 != 0B) goto <D.19776>; else goto <D.19777>;
    <D.19776>:
    D.19766 = handles->entries;
    D.19751 = (long unsigned int) slot;
    D.19767 = D.19751 * 8;
    D.19768 = D.19766 + D.19767;
    D.19769 = *D.19768;
    D.19778 = MEM[(struct MonoObject *)D.19769].vtable;
    D.19779 = D.19778->domain;
    if (D.19779 == domain) goto <D.19780>; else goto <D.19781>;
    <D.19780>:
    D.19735 = handles->bitmap;
    D.19782 = slot / 32;
    D.19783 = (long unsigned int) D.19782;
    D.19784 = D.19783 * 4;
    D.19785 = D.19735 + D.19784;
    D.19735 = handles->bitmap;
    D.19783 = (long unsigned int) D.19782;
    D.19784 = D.19783 * 4;
    D.19785 = D.19735 + D.19784;
    D.19786 = *D.19785;
    D.19741 = slot & 31;
    D.19742 = 1 << D.19741;
    D.19763 = ~D.19742;
    D.19764 = (unsigned int) D.19763;
    D.19787 = D.19786 & D.19764;
    *D.19785 = D.19787;
    D.19766 = handles->entries;
    D.19751 = (long unsigned int) slot;
    D.19767 = D.19751 * 8;
    D.19768 = D.19766 + D.19767;
    *D.19768 = 0B;
    <D.19781>:
    <D.19777>:
    <D.19775>:
    <D.19001>:
    slot = slot + 1;
    <D.19003>:
    D.19788 = handles->size;
    if (D.19788 > slot) goto <D.19002>; else goto <D.19004>;
    <D.19004>:
    {
      int ret;

      ret = pthread_mutex_unlock (&handle_section.mutex);
      if (ret != 0) goto <D.19789>; else goto <D.19790>;
      <D.19789>:
      monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
      <D.19790>:
      D.19791 = ret != 0;
      D.19792 = (long int) D.19791;
      D.19793 = __builtin_expect (D.19792, 0);
      if (D.19793 != 0) goto <D.19794>; else goto <D.19795>;
      <D.19794>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "gc.c", 958, "ret == 0");
      <D.19795>:
    }
  }
  type = type + 1;
  <D.19007>:
  if (type <= 2) goto <D.19006>; else goto <D.19008>;
  <D.19008>:
}


__attribute__((visibility ("hidden")))
GCHandle_CheckCurrentDomain (guint32 gchandle)
{
  MonoBoolean D.19796;
  struct MonoDomain * D.19797;
  int D.19798;

  D.19797 = mono_domain_get ();
  D.19798 = mono_gchandle_is_in_domain (gchandle, D.19797);
  D.19796 = (MonoBoolean) D.19798;
  return D.19796;
}


__attribute__((visibility ("hidden")))
mono_gc_finalize_notify ()
{
  mono_sem_post (&finalizer_sem);
}


__attribute__((visibility ("hidden")))
mono_gc_init ()
{
  int D.19800;
  int D.19803;
  int D.19806;
  void * D.19809;
  void * D.19810;
  void * D.19811;
  void * finalizer_event.22;
  void * pending_done_event.23;
  void * shutdown_event.24;

  InitializeCriticalSection (&handle_section);
  InitializeCriticalSection (&allocator_section);
  InitializeCriticalSection (&finalizer_mutex);
  InitializeCriticalSection (&reference_queue_mutex);
  D.19800 = mono_gc_is_moving ();
  if (D.19800 == 0) goto <D.19801>; else goto <D.19802>;
  <D.19801>:
  mono_gc_register_root (&gc_handles[2].entries, 8, 0B);
  <D.19802>:
  D.19803 = mono_gc_is_moving ();
  if (D.19803 == 0) goto <D.19804>; else goto <D.19805>;
  <D.19804>:
  mono_gc_register_root (&gc_handles[3].entries, 8, 0B);
  <D.19805>:
  mono_counters_register ("Created object count", 516, &mono_stats.new_object_count);
  mono_counters_register ("Minor GC collections", 512, &gc_stats.minor_gc_count);
  mono_counters_register ("Major GC collections", 512, &gc_stats.major_gc_count);
  mono_counters_register ("Minor GC time", 519, &gc_stats.minor_gc_time_usecs);
  mono_counters_register ("Major GC time", 519, &gc_stats.major_gc_time_usecs);
  mono_gc_base_init ();
  D.19806 = mono_gc_is_disabled ();
  if (D.19806 != 0) goto <D.19807>; else goto <D.19808>;
  <D.19807>:
  gc_disabled = 1;
  return;
  <D.19808>:
  D.19809 = CreateEvent (0B, 0, 0, 0B);
  finalizer_event = D.19809;
  D.19810 = CreateEvent (0B, 1, 0, 0B);
  pending_done_event = D.19810;
  D.19811 = CreateEvent (0B, 1, 0, 0B);
  shutdown_event = D.19811;
  finalizer_event.22 = finalizer_event;
  if (finalizer_event.22 == 0B) goto <D.19812>; else goto <D.19815>;
  <D.19815>:
  pending_done_event.23 = pending_done_event;
  if (pending_done_event.23 == 0B) goto <D.19812>; else goto <D.19817>;
  <D.19817>:
  shutdown_event.24 = shutdown_event;
  if (shutdown_event.24 == 0B) goto <D.19812>; else goto <D.19813>;
  <D.19812>:
  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "gc.c", 1152);
  <D.19813>:
  sem_init (&finalizer_sem, 0, 0);
  mono_gc_init_finalizer_thread ();
}


mono_gc_init_finalizer_thread ()
{
  struct MonoDomain * D.19820;
  struct MonoInternalThread * D.19821;
  struct MonoInternalThread * gc_thread.25;
  struct MonoDomain * D.19823;
  struct MonoString * D.19824;

  D.19820 = mono_domain_get ();
  D.19821 = mono_thread_create_internal (D.19820, finalizer_thread, 0B, 0, 1, 0);
  gc_thread = D.19821;
  gc_thread.25 = gc_thread;
  D.19823 = mono_domain_get ();
  D.19824 = mono_string_new (D.19823, "Finalizer");
  ves_icall_System_Threading_Thread_SetName_internal (gc_thread.25, D.19824);
}


finalizer_thread (void * unused)
{
  struct MonoDomain * D.19825;
  struct MonoDomain * D.19826;
  _Bool D.19827;
  long int D.19828;
  long int D.19829;
  struct GSList * domains_to_finalize.26;
  _Bool D.19837;
  long int D.19838;
  long int D.19839;
  struct GSList * D.19844;
  _Bool D.19847;
  long int D.19848;
  long int D.19849;
  _Bool D.19855;
  long int D.19856;
  long int D.19857;
  void * pending_done_event.27;
  int finished.28;
  void * shutdown_event.29;
  guint32 D.19863;

  goto <D.19039>;
  <D.19038>:
  D.19825 = mono_domain_get ();
  D.19826 = mono_get_root_domain ();
  D.19827 = D.19825 != D.19826;
  D.19828 = (long int) D.19827;
  D.19829 = __builtin_expect (D.19828, 0);
  if (D.19829 != 0) goto <D.19830>; else goto <D.19831>;
  <D.19830>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "gc.c", 1069, "mono_domain_get () == mono_get_root_domain ()");
  <D.19831>:
  mono_sem_wait (&finalizer_sem, 1);
  mono_threads_perform_thread_dump ();
  mono_console_handle_async_ops ();
  mono_attach_maybe_start ();
  domains_to_finalize.26 = domains_to_finalize;
  if (domains_to_finalize.26 != 0B) goto <D.19833>; else goto <D.19834>;
  <D.19833>:
  {
    int ret;

    ret = pthread_mutex_lock (&finalizer_mutex.mutex);
    if (ret != 0) goto <D.19835>; else goto <D.19836>;
    <D.19835>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
    <D.19836>:
    D.19837 = ret != 0;
    D.19838 = (long int) D.19837;
    D.19839 = __builtin_expect (D.19838, 0);
    if (D.19839 != 0) goto <D.19840>; else goto <D.19841>;
    <D.19840>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "gc.c", 1087, "ret == 0");
    <D.19841>:
  }
  domains_to_finalize.26 = domains_to_finalize;
  if (domains_to_finalize.26 != 0B) goto <D.19842>; else goto <D.19843>;
  <D.19842>:
  {
    struct DomainFinalizationReq * req;

    domains_to_finalize.26 = domains_to_finalize;
    req = domains_to_finalize.26->data;
    domains_to_finalize.26 = domains_to_finalize;
    D.19844 = monoeg_g_slist_remove (domains_to_finalize.26, req);
    domains_to_finalize = D.19844;
    {
      int ret;

      ret = pthread_mutex_unlock (&finalizer_mutex.mutex);
      if (ret != 0) goto <D.19845>; else goto <D.19846>;
      <D.19845>:
      monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
      <D.19846>:
      D.19847 = ret != 0;
      D.19848 = (long int) D.19847;
      D.19849 = __builtin_expect (D.19848, 0);
      if (D.19849 != 0) goto <D.19850>; else goto <D.19851>;
      <D.19850>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "gc.c", 1091, "ret == 0");
      <D.19851>:
    }
    finalize_domain_objects (req);
  }
  goto <D.19852>;
  <D.19843>:
  {
    int ret;

    ret = pthread_mutex_unlock (&finalizer_mutex.mutex);
    if (ret != 0) goto <D.19853>; else goto <D.19854>;
    <D.19853>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.19854>:
    D.19855 = ret != 0;
    D.19856 = (long int) D.19855;
    D.19857 = __builtin_expect (D.19856, 0);
    if (D.19857 != 0) goto <D.19858>; else goto <D.19859>;
    <D.19858>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "gc.c", 1095, "ret == 0");
    <D.19859>:
  }
  <D.19852>:
  <D.19834>:
  mono_gc_invoke_finalizers ();
  reference_queue_proccess_all ();
  pending_done_event.27 = pending_done_event;
  SetEvent (pending_done_event.27);
  <D.19039>:
  finished.28 = finished;
  if (finished.28 == 0) goto <D.19038>; else goto <D.19040>;
  <D.19040>:
  shutdown_event.29 = shutdown_event;
  SetEvent (shutdown_event.29);
  D.19863 = 0;
  return D.19863;
}


finalize_domain_objects (struct DomainFinalizationReq * req)
{
  struct MonoObject * D.19865;
  void * D.19866;
  struct MonoDomain * domain;
  struct MonoObject * to_finalize[64];
  int count;

  try
    {
      domain = req->domain;
      mono_gc_invoke_finalizers ();
      goto <D.19029>;
      <D.19028>:
      {
        int i;

        i = 0;
        goto <D.19026>;
        <D.19025>:
        D.19865 = to_finalize[i];
        mono_gc_run_finalize (D.19865, 0B);
        i = i + 1;
        <D.19026>:
        if (i < count) goto <D.19025>; else goto <D.19027>;
        <D.19027>:
      }
      <D.19029>:
      count = mono_gc_finalizers_for_domain (domain, &to_finalize, 64);
      if (count != 0) goto <D.19028>; else goto <D.19030>;
      <D.19030>:
      reference_queue_clear_for_domain (domain);
      D.19866 = req->done_event;
      SetEvent (D.19866);
      monoeg_g_free (req);
    }
  finally
    {
      to_finalize = {CLOBBER};
    }
}


reference_queue_clear_for_domain (struct MonoDomain * domain)
{
  struct MonoDomain * D.19867;
  void * * D.19870;
  void (*<Tc6>) (void *) D.19871;
  void * D.19872;
  struct MonoReferenceQueue * queue;

  queue = ref_queues;
  goto <D.19134>;
  <D.19133>:
  {
    struct RefQueueEntry * * iter;
    struct RefQueueEntry * entry;

    iter = &queue->queue;
    goto <D.19131>;
    <D.19130>:
    D.19867 = entry->domain;
    if (D.19867 == domain) goto <D.19868>; else goto <D.19869>;
    <D.19868>:
    D.19870 = &entry->dis_link;
    mono_gc_weak_link_remove (D.19870, 1);
    ref_list_remove_element (iter, entry);
    D.19871 = queue->callback;
    D.19872 = entry->user_data;
    D.19871 (D.19872);
    monoeg_g_free (entry);
    goto <D.19873>;
    <D.19869>:
    iter = &entry->next;
    <D.19873>:
    <D.19131>:
    entry = *iter;
    if (entry != 0B) goto <D.19130>; else goto <D.19132>;
    <D.19132>:
  }
  queue = queue->next;
  <D.19134>:
  if (queue != 0B) goto <D.19133>; else goto <D.19135>;
  <D.19135>:
}


ref_list_remove_element (struct RefQueueEntry * * prev, struct RefQueueEntry * element)
{
  struct RefQueueEntry * D.19874;
  struct RefQueueEntry * D.19876;
  void * D.19877;

  <D.19085>:
  goto <D.19083>;
  <D.19082>:
  D.19874 = *prev;
  prev = &D.19874->next;
  <D.19083>:
  D.19874 = *prev;
  if (D.19874 != element) goto <D.19082>; else goto <D.19084>;
  <D.19084>:
  if (prev != 0B) goto <D.19875>; else goto <D.19086>;
  <D.19875>:
  D.19876 = element->next;
  D.19877 = InterlockedCompareExchangePointer (prev, D.19876, element);
  if (D.19877 != element) goto <D.19085>; else goto <D.19086>;
  <D.19086>:
}


InterlockedCompareExchangePointer (void * volatile * dest, void * exch, void * comp)
{
  void * D.19878;
  long unsigned int comp.30;
  long unsigned int exch.31;
  long unsigned int D.19881;

  comp.30 = (long unsigned int) comp;
  exch.31 = (long unsigned int) exch;
  D.19881 = __sync_val_compare_and_swap_8 (dest, comp.30, exch.31);
  D.19878 = (void *) D.19881;
  return D.19878;
}


reference_queue_proccess_all ()
{
  _Bool D.19885;
  long int D.19886;
  long int D.19887;
  int D.19890;
  struct RefQueueEntry * D.19893;
  _Bool D.19898;
  long int D.19899;
  long int D.19900;
  struct MonoReferenceQueue * D.19903;
  struct MonoReferenceQueue * D.19904;
  _Bool D.19907;
  long int D.19908;
  long int D.19909;
  struct MonoReferenceQueue * * iter;
  struct MonoReferenceQueue * queue;
  void restart = <<< error >>>;

  queue = ref_queues;
  goto <D.19108>;
  <D.19107>:
  reference_queue_proccess (queue);
  queue = queue->next;
  <D.19108>:
  if (queue != 0B) goto <D.19107>; else goto <D.19109>;
  <D.19109>:
  restart:
  {
    int ret;

    ret = pthread_mutex_lock (&reference_queue_mutex.mutex);
    if (ret != 0) goto <D.19883>; else goto <D.19884>;
    <D.19883>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
    <D.19884>:
    D.19885 = ret != 0;
    D.19886 = (long int) D.19885;
    D.19887 = __builtin_expect (D.19886, 0);
    if (D.19887 != 0) goto <D.19888>; else goto <D.19889>;
    <D.19888>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "gc.c", 1424, "ret == 0");
    <D.19889>:
  }
  iter = &ref_queues;
  goto <D.19112>;
  <D.19114>:
  queue = *iter;
  D.19890 = queue->should_be_deleted;
  if (D.19890 == 0) goto <D.19891>; else goto <D.19892>;
  <D.19891>:
  iter = &queue->next;
  // predicted unlikely by continue predictor.
  goto <D.19112>;
  <D.19892>:
  D.19893 = queue->queue;
  if (D.19893 != 0B) goto <D.19894>; else goto <D.19895>;
  <D.19894>:
  {
    int ret;

    ret = pthread_mutex_unlock (&reference_queue_mutex.mutex);
    if (ret != 0) goto <D.19896>; else goto <D.19897>;
    <D.19896>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.19897>:
    D.19898 = ret != 0;
    D.19899 = (long int) D.19898;
    D.19900 = __builtin_expect (D.19899, 0);
    if (D.19900 != 0) goto <D.19901>; else goto <D.19902>;
    <D.19901>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "gc.c", 1432, "ret == 0");
    <D.19902>:
  }
  reference_queue_proccess (queue);
  goto restart;
  <D.19895>:
  D.19903 = queue->next;
  *iter = D.19903;
  monoeg_g_free (queue);
  <D.19112>:
  D.19904 = *iter;
  if (D.19904 != 0B) goto <D.19114>; else goto <D.19115>;
  <D.19115>:
  {
    int ret;

    ret = pthread_mutex_unlock (&reference_queue_mutex.mutex);
    if (ret != 0) goto <D.19905>; else goto <D.19906>;
    <D.19905>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.19906>:
    D.19907 = ret != 0;
    D.19908 = (long int) D.19907;
    D.19909 = __builtin_expect (D.19908, 0);
    if (D.19909 != 0) goto <D.19910>; else goto <D.19911>;
    <D.19910>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "gc.c", 1439, "ret == 0");
    <D.19911>:
  }
}


reference_queue_proccess (struct MonoReferenceQueue * queue)
{
  int D.19915;
  void * * D.19917;
  struct MonoObject * D.19918;
  void (*<Tc6>) (void *) D.19919;
  void * D.19920;
  struct RefQueueEntry * * iter;
  struct RefQueueEntry * entry;

  iter = &queue->queue;
  goto <D.19100>;
  <D.19099>:
  D.19915 = queue->should_be_deleted;
  if (D.19915 != 0) goto <D.19912>; else goto <D.19916>;
  <D.19916>:
  D.19917 = &entry->dis_link;
  D.19918 = mono_gc_weak_link_get (D.19917);
  if (D.19918 == 0B) goto <D.19912>; else goto <D.19913>;
  <D.19912>:
  D.19917 = &entry->dis_link;
  mono_gc_weak_link_remove (D.19917, 1);
  ref_list_remove_element (iter, entry);
  D.19919 = queue->callback;
  D.19920 = entry->user_data;
  D.19919 (D.19920);
  monoeg_g_free (entry);
  goto <D.19914>;
  <D.19913>:
  iter = &entry->next;
  <D.19914>:
  <D.19100>:
  entry = *iter;
  if (entry != 0B) goto <D.19099>; else goto <D.19101>;
  <D.19101>:
}


__attribute__((visibility ("hidden")))
mono_gc_cleanup ()
{
  int gc_disabled.32;
  void * shutdown_event.33;
  struct MonoInternalThread * D.19925;
  struct MonoInternalThread * gc_thread.34;
  unsigned int D.19929;
  void * D.19932;
  unsigned int D.19933;
  unsigned int D.19938;
  _Bool D.19939;
  long int D.19940;
  long int D.19941;
  long unsigned int D.19944;

  gc_disabled.32 = gc_disabled;
  if (gc_disabled.32 == 0) goto <D.19922>; else goto <D.19923>;
  <D.19922>:
  shutdown_event.33 = shutdown_event;
  ResetEvent (shutdown_event.33);
  finished = 1;
  D.19925 = mono_thread_internal_current ();
  gc_thread.34 = gc_thread;
  if (D.19925 != gc_thread.34) goto <D.19927>; else goto <D.19928>;
  <D.19927>:
  mono_gc_finalize_notify ();
  shutdown_event.33 = shutdown_event;
  D.19929 = WaitForSingleObjectEx (shutdown_event.33, 2000, 0);
  if (D.19929 == 258) goto <D.19930>; else goto <D.19931>;
  <D.19930>:
  {
    int ret;

    suspend_finalizers = 1;
    gc_thread.34 = gc_thread;
    mono_thread_internal_stop (gc_thread.34);
    gc_thread.34 = gc_thread;
    D.19932 = gc_thread.34->handle;
    D.19933 = WaitForSingleObjectEx (D.19932, 100, 1);
    ret = (int) D.19933;
    if (ret == 258) goto <D.19934>; else goto <D.19935>;
    <D.19934>:
    monoeg_g_log (0B, 16, "Shutting down finalizer thread timed out.");
    goto <D.19936>;
    <D.19935>:
    Sleep (100);
    <D.19936>:
  }
  goto <D.19937>;
  <D.19931>:
  {
    int ret;

    gc_thread.34 = gc_thread;
    D.19932 = gc_thread.34->handle;
    D.19938 = WaitForSingleObjectEx (D.19932, 4294967295, 1);
    ret = (int) D.19938;
    D.19939 = ret != 0;
    D.19940 = (long int) D.19939;
    D.19941 = __builtin_expect (D.19940, 0);
    if (D.19941 != 0) goto <D.19942>; else goto <D.19943>;
    <D.19942>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "gc.c", 1208, "ret == WAIT_OBJECT_0");
    <D.19943>:
    gc_thread.34 = gc_thread;
    D.19944 = gc_thread.34->tid;
    ret = pthread_join (D.19944, 0B);
    D.19939 = ret != 0;
    D.19940 = (long int) D.19939;
    D.19941 = __builtin_expect (D.19940, 0);
    if (D.19941 != 0) goto <D.19945>; else goto <D.19946>;
    <D.19945>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "gc.c", 1216, "ret == 0");
    <D.19946>:
  }
  <D.19937>:
  <D.19928>:
  gc_thread = 0B;
  <D.19923>:
  mono_reference_queue_cleanup ();
  DeleteCriticalSection (&handle_section);
  DeleteCriticalSection (&allocator_section);
  DeleteCriticalSection (&finalizer_mutex);
  DeleteCriticalSection (&reference_queue_mutex);
}


mono_reference_queue_cleanup ()
{
  struct MonoReferenceQueue * queue;

  queue = ref_queues;
  goto <D.19122>;
  <D.19121>:
  queue->should_be_deleted = 1;
  queue = queue->next;
  <D.19122>:
  if (queue != 0B) goto <D.19121>; else goto <D.19123>;
  <D.19123>:
  reference_queue_proccess_all ();
}


__attribute__((visibility ("hidden")))
mono_gc_is_finalizer_internal_thread (struct MonoInternalThread * thread)
{
  gboolean D.19947;
  struct MonoInternalThread * gc_thread.35;
  _Bool D.19949;

  gc_thread.35 = gc_thread;
  D.19949 = thread == gc_thread.35;
  D.19947 = (gboolean) D.19949;
  return D.19947;
}


mono_gc_is_finalizer_thread (struct MonoThread * thread)
{
  gboolean D.19951;
  struct _MonoInternalThread * D.19952;

  D.19952 = thread->internal_thread;
  D.19951 = mono_gc_is_finalizer_internal_thread (D.19952);
  return D.19951;
}


__attribute__((visibility ("hidden")))
mono_gc_parse_environment_string_extract_number (const char * str, glong * out)
{
  long unsigned int D.19954;
  gboolean D.19957;
  sizetype D.19958;
  sizetype D.19959;
  const char * D.19960;
  int D.19961;
  const short unsigned int * * D.19962;
  const short unsigned int * D.19963;
  long unsigned int D.19964;
  long unsigned int D.19965;
  const short unsigned int * D.19966;
  short unsigned int D.19967;
  int D.19968;
  int D.19969;
  int * D.19972;
  int D.19977;
  unsigned long val.36;
  unsigned long D.19980;
  char * endptr.37;
  char * D.19987;
  char D.19988;
  long unsigned int val.38;
  long unsigned int D.19994;
  char * endptr;
  int len;
  int shift;
  glong val;
  gboolean is_suffix;
  char suffix;

  try
    {
      D.19954 = __strlen_g (str);
      len = (int) D.19954;
      shift = 0;
      is_suffix = 0;
      if (len == 0) goto <D.19955>; else goto <D.19956>;
      <D.19955>:
      D.19957 = 0;
      return D.19957;
      <D.19956>:
      D.19958 = (sizetype) len;
      D.19959 = D.19958 + 18446744073709551615;
      D.19960 = str + D.19959;
      suffix = *D.19960;
      D.19961 = (int) suffix;
      switch (D.19961) <default: <D.19075>, case 71: <D.19069>, case 75: <D.19073>, case 77: <D.19071>, case 103: <D.19068>, case 107: <D.19072>, case 109: <D.19070>>
      <D.19068>:
      <D.19069>:
      shift = shift + 10;
      <D.19070>:
      <D.19071>:
      shift = shift + 10;
      <D.19072>:
      <D.19073>:
      shift = shift + 10;
      is_suffix = 1;
      goto <D.19074>;
      <D.19075>:
      D.19962 = __ctype_b_loc ();
      D.19963 = *D.19962;
      D.19964 = (long unsigned int) suffix;
      D.19965 = D.19964 * 2;
      D.19966 = D.19963 + D.19965;
      D.19967 = *D.19966;
      D.19968 = (int) D.19967;
      D.19969 = D.19968 & 8;
      if (D.19969 == 0) goto <D.19970>; else goto <D.19971>;
      <D.19970>:
      D.19957 = 0;
      return D.19957;
      <D.19971>:
      goto <D.19074>;
      <D.19074>:
      D.19972 = __errno_location ();
      *D.19972 = 0;
      val = strtol (str, &endptr, 10);
      D.19972 = __errno_location ();
      D.19977 = *D.19972;
      if (D.19977 == 34) goto <D.19978>; else goto <D.19973>;
      <D.19978>:
      val.36 = (unsigned long) val;
      D.19980 = val.36 + 9223372036854775807;
      if (D.19980 > 18446744073709551613) goto <D.19974>; else goto <D.19973>;
      <D.19973>:
      D.19972 = __errno_location ();
      D.19977 = *D.19972;
      if (D.19977 != 0) goto <D.19981>; else goto <D.19975>;
      <D.19981>:
      if (val == 0) goto <D.19974>; else goto <D.19975>;
      <D.19975>:
      endptr.37 = endptr;
      if (endptr.37 == str) goto <D.19974>; else goto <D.19976>;
      <D.19974>:
      D.19957 = 0;
      return D.19957;
      <D.19976>:
      if (is_suffix != 0) goto <D.19983>; else goto <D.19984>;
      <D.19983>:
      {
        gulong unshifted;

        if (val < 0) goto <D.19985>; else goto <D.19986>;
        <D.19985>:
        D.19957 = 0;
        return D.19957;
        <D.19986>:
        endptr.37 = endptr;
        D.19987 = endptr.37 + 1;
        D.19988 = *D.19987;
        if (D.19988 != 0) goto <D.19989>; else goto <D.19990>;
        <D.19989>:
        D.19957 = 0;
        return D.19957;
        <D.19990>:
        unshifted = (gulong) val;
        val = val << shift;
        if (val < 0) goto <D.19991>; else goto <D.19992>;
        <D.19991>:
        D.19957 = 0;
        return D.19957;
        <D.19992>:
        val.38 = (long unsigned int) val;
        D.19994 = val.38 >> shift;
        if (D.19994 != unshifted) goto <D.19995>; else goto <D.19996>;
        <D.19995>:
        D.19957 = 0;
        return D.19957;
        <D.19996>:
      }
      <D.19984>:
      *out = val;
      D.19957 = 1;
      return D.19957;
    }
  finally
    {
      endptr = {CLOBBER};
    }
}


__attribute__((__gnu_inline__))
__strlen_g (const char * __str)
{
  size_t D.19999;
  long int __ptr.39;
  long int __str.40;
  long int D.20002;
  char * __ptr;
  char * __tmp;

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


mono_gc_reference_queue_new (void (*mono_reference_queue_callback) (void *) callback)
{
  _Bool D.20006;
  long int D.20007;
  long int D.20008;
  struct MonoReferenceQueue * ref_queues.41;
  _Bool D.20014;
  long int D.20015;
  long int D.20016;
  struct MonoReferenceQueue * D.20019;
  struct MonoReferenceQueue * res;

  res = monoeg_malloc0 (32);
  res->callback = callback;
  {
    int ret;

    ret = pthread_mutex_lock (&reference_queue_mutex.mutex);
    if (ret != 0) goto <D.20004>; else goto <D.20005>;
    <D.20004>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
    <D.20005>:
    D.20006 = ret != 0;
    D.20007 = (long int) D.20006;
    D.20008 = __builtin_expect (D.20007, 0);
    if (D.20008 != 0) goto <D.20009>; else goto <D.20010>;
    <D.20009>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "gc.c", 1497, "ret == 0");
    <D.20010>:
  }
  ref_queues.41 = ref_queues;
  res->next = ref_queues.41;
  ref_queues = res;
  {
    int ret;

    ret = pthread_mutex_unlock (&reference_queue_mutex.mutex);
    if (ret != 0) goto <D.20012>; else goto <D.20013>;
    <D.20012>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.20013>:
    D.20014 = ret != 0;
    D.20015 = (long int) D.20014;
    D.20016 = __builtin_expect (D.20015, 0);
    if (D.20016 != 0) goto <D.20017>; else goto <D.20018>;
    <D.20017>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "gc.c", 1500, "ret == 0");
    <D.20018>:
  }
  D.20019 = res;
  return D.20019;
}


mono_gc_reference_queue_add (struct MonoReferenceQueue * queue, struct MonoObject * obj, void * user_data)
{
  int D.20021;
  mono_bool D.20024;
  struct MonoVTable * D.20025;
  struct MonoDomain * D.20026;
  void * * D.20027;
  struct RefQueueEntry * * D.20028;
  struct RefQueueEntry * entry;

  D.20021 = queue->should_be_deleted;
  if (D.20021 != 0) goto <D.20022>; else goto <D.20023>;
  <D.20022>:
  D.20024 = 0;
  return D.20024;
  <D.20023>:
  entry = monoeg_malloc0 (40);
  entry->user_data = user_data;
  D.20025 = obj->vtable;
  D.20026 = D.20025->domain;
  entry->domain = D.20026;
  D.20027 = &entry->dis_link;
  mono_gc_weak_link_add (D.20027, obj, 1);
  D.20028 = &queue->queue;
  ref_list_push (D.20028, entry);
  D.20024 = 1;
  return D.20024;
}


ref_list_push (struct RefQueueEntry * * head, struct RefQueueEntry * value)
{
  void * D.20030;
  struct RefQueueEntry * current;

  <D.19092>:
  current = *head;
  value->next = current;
  D.20030 = InterlockedCompareExchangePointer (head, value, current);
  if (D.20030 != current) goto <D.19092>; else goto <D.19093>;
  <D.19093>:
}


mono_gc_reference_queue_free (struct MonoReferenceQueue * queue)
{
  queue->should_be_deleted = 1;
}