mono_gc_base_init ()
{
  int gc_initialized.0;
  long unsigned int D.21394;
  void * sstart.1;
  unsigned int size.2;
  char * GC_stackbottom.3;
  char * stack_bottom.4;
  int D.21404;
  char * D.21407;
  char D.21410;
  int D.21412;
  long int max_heap.5;
  struct _IO_FILE * stderr.6;
  long unsigned int max_heap.7;
  char * D.21419;
  struct MonoThreadInfoCallbacks cb;
  const char * env;

  try
    {
      gc_initialized.0 = gc_initialized;
      if (gc_initialized.0 != 0) goto <D.21392>; else goto <D.21393>;
      <D.21392>:
      return;
      <D.21393>:
      {
        size_t size;
        void * sstart;
        union pthread_attr_t attr;

        try
          {
            D.21394 = pthread_self ();
            pthread_getattr_np (D.21394, &attr);
            pthread_attr_getstack (&attr, &sstart, &size);
            pthread_attr_destroy (&attr);
            sstart.1 = sstart;
            if (sstart.1 != 0B) goto <D.21396>; else goto <D.21397>;
            <D.21396>:
            sstart.1 = sstart;
            size.2 = size;
            GC_stackbottom.3 = sstart.1 + size.2;
            GC_stackbottom = GC_stackbottom.3;
            goto <D.21400>;
            <D.21397>:
            {
              int dummy;
              gsize stack_bottom;

              try
                {
                  stack_bottom = (gsize) &dummy;
                  stack_bottom = stack_bottom + 4095;
                  stack_bottom = stack_bottom & 4294963200;
                  stack_bottom.4 = (char *) stack_bottom;
                  GC_stackbottom = stack_bottom.4;
                }
              finally
                {
                  dummy = {CLOBBER};
                }
            }
            <D.21400>:
          }
        finally
          {
            size = {CLOBBER};
            sstart = {CLOBBER};
            attr = {CLOBBER};
          }
      }
      GC_no_dls = 1;
      GC_init ();
      GC_oom_fn = mono_gc_out_of_memory;
      GC_set_warn_proc (mono_gc_warning);
      GC_finalize_on_demand = 1;
      GC_finalizer_notifier = mono_gc_finalize_notify;
      GC_init_gcj_malloc (5, 0B);
      env = monoeg_g_getenv ("MONO_GC_PARAMS");
      if (env != 0B) goto <D.21402>; else goto <D.21403>;
      <D.21402>:
      {
        char * * ptr;
        char * * opts;

        opts = monoeg_g_strsplit (env, ",", -1);
        ptr = opts;
        goto <D.21095>;
        <D.21094>:
        {
          char * opt;

          opt = *ptr;
          D.21404 = monoeg_g_str_has_prefix (opt, "max-heap-size=");
          if (D.21404 != 0) goto <D.21405>; else goto <D.21406>;
          <D.21405>:
          {
            glong max_heap;

            try
              {
                D.21407 = __builtin_strchr (opt, 61);
                opt = D.21407 + 1;
                D.21410 = *opt;
                if (D.21410 != 0) goto <D.21411>; else goto <D.21408>;
                <D.21411>:
                D.21412 = mono_gc_parse_environment_string_extract_number (opt, &max_heap);
                if (D.21412 != 0) goto <D.21413>; else goto <D.21408>;
                <D.21413>:
                max_heap.5 = max_heap;
                if (max_heap.5 <= 16777215) goto <D.21415>; else goto <D.21416>;
                <D.21415>:
                stderr.6 = stderr;
                fprintf (stderr.6, "max-heap-size must be at least %dMb.\n", 16);
                exit (1);
                <D.21416>:
                max_heap.5 = max_heap;
                max_heap.7 = (long unsigned int) max_heap.5;
                GC_set_max_heap_size (max_heap.7);
                goto <D.21409>;
                <D.21408>:
                stderr.6 = stderr;
                fprintf (stderr.6, "max-heap-size must be an integer.\n");
                exit (1);
                <D.21409>:
                // predicted unlikely by continue predictor.
                goto <D.21093>;
              }
            finally
              {
                max_heap = {CLOBBER};
              }
          }
          <D.21406>:
        }
        <D.21093>:
        ptr = ptr + 4;
        <D.21095>:
        D.21419 = *ptr;
        if (D.21419 != 0B) goto <D.21094>; else goto <D.21096>;
        <D.21096>:
        monoeg_g_strfreev (opts);
      }
      <D.21403>:
      memset (&cb, 0, 24);
      cb.thread_register = boehm_thread_register;
      cb.mono_method_is_critical = mono_runtime_is_critical_method;
      cb.mono_gc_pthread_create = mono_gc_pthread_create;
      mono_threads_init (&cb, 344);
      pthread_mutex_init (&mono_gc_lock, 0B);
      mono_gc_enable_events ();
      gc_initialized = 1;
    }
  finally
    {
      cb = {CLOBBER};
    }
}


boehm_thread_register (struct MonoThreadInfo * info, void * baseptr)
{
  int D.21424;
  void * D.21427;
  void * iftmp.8;
  int D.21429;

  D.21424 = mono_gc_is_gc_thread ();
  if (D.21424 != 0) goto <D.21425>; else goto <D.21426>;
  <D.21425>:
  D.21427 = info;
  return D.21427;
  <D.21426>:
  D.21429 = GC_thread_register_foreign (baseptr);
  if (D.21429 != 0) goto <D.21430>; else goto <D.21431>;
  <D.21430>:
  iftmp.8 = info;
  goto <D.21432>;
  <D.21431>:
  iftmp.8 = 0B;
  <D.21432>:
  D.21427 = iftmp.8;
  return D.21427;
}


mono_gc_warning (char * msg, GC_word arg)
{
  mono_trace (16, 8, msg, arg);
}


fprintf (struct FILE * restrict __stream, const char * restrict __fmt)
{
  int D.21434;

  D.21434 = __fprintf_chk (__stream, 1, __fmt, __builtin_va_arg_pack ());
  return D.21434;
}


memset (void * __dest, int __ch, size_t __len)
{
  int D.21438;
  int D.21443;
  void * D.21445;
  unsigned int D.21446;

  D.21438 = __builtin_constant_p (__len);
  if (D.21438 != 0) goto <D.21439>; else goto <D.21440>;
  <D.21439>:
  if (__len == 0) goto <D.21441>; else goto <D.21442>;
  <D.21441>:
  D.21443 = __builtin_constant_p (__ch);
  if (D.21443 == 0) goto <D.21436>; else goto <D.21444>;
  <D.21444>:
  if (__ch != 0) goto <D.21436>; else goto <D.21437>;
  <D.21436>:
  __warn_memset_zero_len ();
  D.21445 = __dest;
  return D.21445;
  <D.21437>:
  <D.21442>:
  <D.21440>:
  D.21446 = __builtin_object_size (__dest, 0);
  D.21445 = __builtin___memset_chk (__dest, __ch, __len, D.21446);
  return D.21445;
}


mono_gc_collect (int generation)
{
  struct MonoPerfCounters * mono_perfcounters.9;
  unsigned int D.21449;
  unsigned int D.21450;

  mono_perfcounters.9 = mono_perfcounters;
  D.21449 = mono_perfcounters.9->gc_induced;
  D.21450 = D.21449 + 1;
  mono_perfcounters.9->gc_induced = D.21450;
  GC_gcollect ();
}


mono_gc_max_generation ()
{
  int D.21451;

  D.21451 = 0;
  return D.21451;
}


mono_gc_get_generation (struct MonoObject * object)
{
  int D.21453;

  D.21453 = 0;
  return D.21453;
}


mono_gc_collection_count (int generation)
{
  int D.21455;
  long unsigned int GC_gc_no.10;

  GC_gc_no.10 = GC_gc_no;
  D.21455 = (int) GC_gc_no.10;
  return D.21455;
}


mono_gc_add_memory_pressure (gint64 value)
{

}


mono_gc_get_used_size ()
{
  int64_t D.21458;
  unsigned int D.21459;
  unsigned int D.21460;
  unsigned int D.21461;

  D.21459 = GC_get_heap_size ();
  D.21460 = GC_get_free_bytes ();
  D.21461 = D.21459 - D.21460;
  D.21458 = (int64_t) D.21461;
  return D.21458;
}


mono_gc_get_heap_size ()
{
  int64_t D.21463;
  unsigned int D.21464;

  D.21464 = GC_get_heap_size ();
  D.21463 = (int64_t) D.21464;
  return D.21463;
}


mono_gc_is_gc_thread ()
{
  gboolean D.21466;

  D.21466 = GC_thread_is_registered ();
  return D.21466;
}


mono_gc_register_thread (void * baseptr)
{
  gboolean D.21468;
  struct MonoThreadInfo * D.21469;
  _Bool D.21470;

  D.21469 = mono_thread_info_attach (baseptr);
  D.21470 = D.21469 != 0B;
  D.21468 = (gboolean) D.21470;
  return D.21468;
}


mono_object_is_alive (struct MonoObject * o)
{
  gboolean D.21472;

  D.21472 = GC_is_marked (o);
  return D.21472;
}


mono_gc_walk_heap (int flags, int (*MonoGCReferences) (struct MonoObject *, struct MonoClass *, uintptr_t, uintptr_t, struct MonoObject * *, uintptr_t *, void *) callback, void * data)
{
  int D.21474;

  D.21474 = 1;
  return D.21474;
}


mono_gc_enable_events ()
{
  GC_notify_event = on_gc_notification;
  GC_on_heap_resize = on_gc_heap_resize;
}


on_gc_heap_resize (size_t new_size)
{
  unsigned int D.21476;
  struct MonoPerfCounters * mono_perfcounters.11;
  unsigned int D.21480;
  long long int D.21481;
  guint64 heap_size;

  D.21476 = GC_get_heap_size ();
  heap_size = (guint64) D.21476;
  mono_perfcounters.11 = mono_perfcounters;
  if (mono_perfcounters.11 != 0B) goto <D.21478>; else goto <D.21479>;
  <D.21478>:
  mono_perfcounters.11 = mono_perfcounters;
  D.21480 = (unsigned int) heap_size;
  mono_perfcounters.11->gc_committed_bytes = D.21480;
  mono_perfcounters.11 = mono_perfcounters;
  D.21480 = (unsigned int) heap_size;
  mono_perfcounters.11->gc_reserved_bytes = D.21480;
  mono_perfcounters.11 = mono_perfcounters;
  D.21480 = (unsigned int) heap_size;
  mono_perfcounters.11->gc_gen0size = D.21480;
  <D.21479>:
  D.21481 = (long long int) new_size;
  mono_profiler_gc_heap_resize (D.21481);
}


on_gc_notification (GCEventType event)
{
  struct MonoPerfCounters * mono_perfcounters.12;
  unsigned int D.21485;
  unsigned int D.21486;
  int D.21487;
  int D.21488;
  long long int gc_start_time.13;
  unsigned int D.21492;
  unsigned int D.21493;
  long long unsigned int D.21494;
  unsigned int D.21495;
  unsigned int D.21496;
  long long int D.21497;
  long long int gc_start_time.14;
  long long int D.21499;
  long long int D.21500;
  long long int D.21501;
  long long int D.21502;
  long long int D.21503;
  long long int D.21504;
  long long int D.21505;
  MonoGCEvent e;

  e = event;
  switch (e) <default: <D.21506>, case 0: <D.21148>, case 5: <D.21149>, case 6: <D.21143>, case 7: <D.21145>, case 8: <D.21146>, case 9: <D.21147>>
  <D.21143>:
  mono_thread_info_suspend_lock ();
  goto <D.21144>;
  <D.21145>:
  goto <D.21144>;
  <D.21146>:
  goto <D.21144>;
  <D.21147>:
  mono_thread_info_suspend_unlock ();
  goto <D.21144>;
  <D.21148>:
  mono_perfcounters.12 = mono_perfcounters;
  if (mono_perfcounters.12 != 0B) goto <D.21483>; else goto <D.21484>;
  <D.21483>:
  mono_perfcounters.12 = mono_perfcounters;
  D.21485 = mono_perfcounters.12->gc_collections0;
  D.21486 = D.21485 + 1;
  mono_perfcounters.12->gc_collections0 = D.21486;
  <D.21484>:
  D.21487 = gc_stats.major_gc_count;
  D.21488 = D.21487 + 1;
  gc_stats.major_gc_count = D.21488;
  gc_start_time.13 = mono_100ns_ticks ();
  gc_start_time = gc_start_time.13;
  goto <D.21144>;
  <D.21149>:
  mono_perfcounters.12 = mono_perfcounters;
  if (mono_perfcounters.12 != 0B) goto <D.21490>; else goto <D.21491>;
  <D.21490>:
  {
    guint64 heap_size;
    guint64 used_size;

    D.21492 = GC_get_heap_size ();
    heap_size = (guint64) D.21492;
    D.21493 = GC_get_free_bytes ();
    D.21494 = (long long unsigned int) D.21493;
    used_size = heap_size - D.21494;
    mono_perfcounters.12 = mono_perfcounters;
    D.21495 = (unsigned int) used_size;
    mono_perfcounters.12->gc_total_bytes = D.21495;
    mono_perfcounters.12 = mono_perfcounters;
    D.21496 = (unsigned int) heap_size;
    mono_perfcounters.12->gc_committed_bytes = D.21496;
    mono_perfcounters.12 = mono_perfcounters;
    D.21496 = (unsigned int) heap_size;
    mono_perfcounters.12->gc_reserved_bytes = D.21496;
    mono_perfcounters.12 = mono_perfcounters;
    D.21496 = (unsigned int) heap_size;
    mono_perfcounters.12->gc_gen0size = D.21496;
  }
  <D.21491>:
  D.21497 = mono_100ns_ticks ();
  gc_start_time.14 = gc_start_time;
  D.21499 = D.21497 - gc_start_time.14;
  D.21500 = D.21499 / 10;
  D.21501 = gc_stats.major_gc_time_usecs;
  D.21502 = D.21501 + D.21500;
  gc_stats.major_gc_time_usecs = D.21502;
  D.21503 = mono_100ns_ticks ();
  gc_start_time.14 = gc_start_time;
  D.21504 = D.21503 - gc_start_time.14;
  D.21505 = D.21504 / 10;
  mono_trace (32, 8, "gc took %d usecs", D.21505);
  goto <D.21144>;
  <D.21506>:
  <D.21144>:
  mono_profiler_gc_event (e, 0);
}


mono_gc_register_root (char * start, size_t size, void * descr)
{
  sizetype D.21507;
  char * D.21508;
  int D.21509;

  D.21507 = size + 1;
  D.21508 = start + D.21507;
  GC_add_roots (start, D.21508);
  D.21509 = 1;
  return D.21509;
}


mono_gc_deregister_root (char * addr)
{
  char * D.21511;

  D.21511 = addr + 5;
  GC_remove_roots (addr, D.21511);
}


mono_gc_weak_link_add (void * * link_addr, struct MonoObject * obj, gboolean track)
{
  long unsigned int obj.15;
  long unsigned int D.21513;
  void * D.21514;

  obj.15 = (long unsigned int) obj;
  D.21513 = ~obj.15;
  D.21514 = (void *) D.21513;
  *link_addr = D.21514;
  if (track != 0) goto <D.21515>; else goto <D.21516>;
  <D.21515>:
  GC_register_long_link (link_addr, obj);
  goto <D.21517>;
  <D.21516>:
  GC_general_register_disappearing_link (link_addr, obj);
  <D.21517>:
}


mono_gc_weak_link_remove (void * * link_addr, gboolean track)
{
  if (track != 0) goto <D.21518>; else goto <D.21519>;
  <D.21518>:
  GC_unregister_long_link (link_addr);
  goto <D.21520>;
  <D.21519>:
  GC_unregister_disappearing_link (link_addr);
  <D.21520>:
  *link_addr = 0B;
}


mono_gc_weak_link_get (void * * link_addr)
{
  struct MonoObject * D.21523;
  struct MonoObject * obj;

  obj = GC_call_with_alloc_lock (reveal_link, link_addr);
  if (obj == 4294967295B) goto <D.21521>; else goto <D.21522>;
  <D.21521>:
  D.21523 = 0B;
  return D.21523;
  <D.21522>:
  D.21523 = obj;
  return D.21523;
}


reveal_link (void * link_addr)
{
  void * D.21525;
  void * D.21526;
  long unsigned int D.21527;
  long unsigned int D.21528;
  void * * link_a;

  link_a = link_addr;
  D.21526 = *link_a;
  D.21527 = (long unsigned int) D.21526;
  D.21528 = ~D.21527;
  D.21525 = (void *) D.21528;
  return D.21525;
}


mono_gc_make_descr_for_string (gsize * bitmap, int numbits)
{
  void * D.21530;

  D.21530 = mono_gc_make_descr_from_bitmap (bitmap, numbits);
  return D.21530;
}


mono_gc_make_descr_for_object (gsize * bitmap, int numbits, size_t obj_size)
{
  void * D.21532;

  D.21532 = mono_gc_make_descr_from_bitmap (bitmap, numbits);
  return D.21532;
}


mono_gc_make_descr_for_array (int vector, gsize * elem_bitmap, int numbits, size_t elem_size)
{
  void * D.21534;

  D.21534 = 0B;
  return D.21534;
}


mono_gc_make_descr_from_bitmap (gsize * bitmap, int numbits)
{
  void * D.21538;
  unsigned int numbits.16;
  long unsigned int D.21540;

  if (numbits > 29) goto <D.21536>; else goto <D.21537>;
  <D.21536>:
  D.21538 = 0B;
  return D.21538;
  <D.21537>:
  numbits.16 = (unsigned int) numbits;
  D.21540 = GC_make_descriptor (bitmap, numbits.16);
  D.21538 = (void *) D.21540;
  return D.21538;
}


mono_gc_make_root_descr_all_refs (int numbits)
{
  void * D.21542;

  D.21542 = 0B;
  return D.21542;
}


mono_gc_alloc_fixed (size_t size, void * descr)
{
  void * D.21546;
  long unsigned int descr.17;

  if (descr != 0B) goto <D.21544>; else goto <D.21545>;
  <D.21544>:
  descr.17 = (long unsigned int) descr;
  D.21546 = GC_malloc_explicitly_typed (size, descr.17);
  return D.21546;
  <D.21545>:
  D.21546 = GC_malloc (size);
  return D.21546;
}


mono_gc_free_fixed (void * addr)
{

}


mono_gc_invoke_finalizers ()
{
  int D.21549;
  int D.21552;

  D.21549 = GC_should_invoke_finalizers ();
  if (D.21549 != 0) goto <D.21550>; else goto <D.21551>;
  <D.21550>:
  D.21552 = GC_invoke_finalizers ();
  return D.21552;
  <D.21551>:
  D.21552 = 0;
  return D.21552;
}


mono_gc_pending_finalizers ()
{
  gboolean D.21554;

  D.21554 = GC_should_invoke_finalizers ();
  return D.21554;
}


mono_gc_wbarrier_set_field (struct MonoObject * obj, void * field_ptr, struct MonoObject * value)
{
  MEM[(void * *)field_ptr] = value;
}


mono_gc_wbarrier_set_arrayref (struct MonoArray * arr, void * slot_ptr, struct MonoObject * value)
{
  MEM[(void * *)slot_ptr] = value;
}


mono_gc_wbarrier_arrayref_copy (void * dest_ptr, void * src_ptr, int count)
{
  unsigned int count.18;
  unsigned int D.21557;

  count.18 = (unsigned int) count;
  D.21557 = count.18 * 4;
  mono_gc_memmove_aligned (dest_ptr, src_ptr, D.21557);
}


mono_gc_wbarrier_generic_store (void * ptr, struct MonoObject * value)
{
  MEM[(void * *)ptr] = value;
}


mono_gc_wbarrier_generic_store_atomic (void * ptr, struct MonoObject * value)
{
  InterlockedWritePointer (ptr, value);
}


InterlockedWritePointer (void * volatile * dst, void * val)
{
  InterlockedExchangePointer (dst, val);
}


InterlockedExchangePointer (void * volatile * val, void * new_val)
{
  unsigned int old_val.19;
  unsigned int new_val.20;
  unsigned int D.21560;
  void * D.21561;
  void * D.21562;
  void * old_val;

  <D.20170>:
  old_val = *val;
  old_val.19 = (unsigned int) old_val;
  new_val.20 = (unsigned int) new_val;
  D.21560 = __sync_val_compare_and_swap_4 (val, old_val.19, new_val.20);
  D.21561 = (void *) D.21560;
  if (D.21561 != old_val) goto <D.20170>; else goto <D.20171>;
  <D.20171>:
  D.21562 = old_val;
  return D.21562;
}


mono_gc_wbarrier_generic_nostore (void * ptr)
{

}


mono_gc_wbarrier_value_copy (void * dest, void * src, int count, struct MonoClass * klass)
{
  int D.21564;
  int D.21565;
  unsigned int D.21566;

  D.21564 = mono_class_value_size (klass, 0B);
  D.21565 = D.21564 * count;
  D.21566 = (unsigned int) D.21565;
  mono_gc_memmove_atomic (dest, src, D.21566);
}


mono_gc_wbarrier_object_copy (struct MonoObject * obj, struct MonoObject * src)
{
  void * D.21567;
  const void * D.21568;
  struct MonoVTable * D.21569;
  struct MonoClass * D.21570;
  int D.21571;
  unsigned int D.21572;
  unsigned int D.21573;

  D.21567 = obj + 8;
  D.21568 = src + 8;
  D.21569 = obj->vtable;
  D.21570 = D.21569->klass;
  D.21571 = D.21570->instance_size;
  D.21572 = (unsigned int) D.21571;
  D.21573 = D.21572 + 4294967288;
  mono_gc_memmove_aligned (D.21567, D.21568, D.21573);
}


mono_gc_clear_domain (struct MonoDomain * domain)
{

}


mono_gc_get_suspend_signal ()
{
  int D.21574;

  D.21574 = -1;
  return D.21574;
}


mono_gc_get_managed_allocator (struct MonoClass * klass, gboolean for_box)
{
  struct MonoMethod * D.21576;

  D.21576 = 0B;
  return D.21576;
}


mono_gc_get_managed_array_allocator (struct MonoClass * klass)
{
  struct MonoMethod * D.21578;

  D.21578 = 0B;
  return D.21578;
}


mono_gc_get_managed_allocator_by_type (int atype)
{
  struct MonoMethod * D.21580;

  D.21580 = 0B;
  return D.21580;
}


mono_gc_get_managed_allocator_types ()
{
  guint32 D.21582;

  D.21582 = 0;
  return D.21582;
}


mono_gc_get_write_barrier ()
{
  struct MonoMethod * D.21584;

  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "boehm-gc.c", 1047);
  D.21584 = 0B;
  return D.21584;
}


mono_gc_get_gc_name ()
{
  const char * D.21586;

  D.21586 = "boehm";
  return D.21586;
}


mono_gc_invoke_with_gc_lock (void * (*MonoGCLockedCallbackFunc) (void *) func, void * data)
{
  void * D.21588;

  D.21588 = GC_call_with_alloc_lock (func, data);
  return D.21588;
}


mono_gc_get_description ()
{
  char * D.21590;

  D.21590 = monoeg_strdup ("Included Boehm (with typed GC and Parallel Mark)");
  return D.21590;
}


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

  if (str != 0B) goto <D.21592>; else goto <D.21593>;
  <D.21592>:
  D.21594 = __strdup (str);
  return D.21594;
  <D.21593>:
  D.21594 = 0B;
  return D.21594;
}


mono_gc_set_desktop_mode ()
{
  GC_dont_expand = 1;
}


mono_gc_is_moving ()
{
  gboolean D.21596;

  D.21596 = 0;
  return D.21596;
}


mono_gc_is_disabled ()
{
  int GC_dont_gc.21;
  const gchar * D.21602;
  gboolean D.21603;

  GC_dont_gc.21 = GC_dont_gc;
  if (GC_dont_gc.21 != 0) goto <D.21598>; else goto <D.21601>;
  <D.21601>:
  D.21602 = monoeg_g_getenv ("GC_DONT_GC");
  if (D.21602 != 0B) goto <D.21598>; else goto <D.21599>;
  <D.21598>:
  D.21603 = 1;
  return D.21603;
  <D.21599>:
  D.21603 = 0;
  return D.21603;
}


mono_gc_wbarrier_value_copy_bitmap (void * _dest, void * _src, int size, unsigned int bitmap)
{
  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "boehm-gc.c", 1095);
}


mono_gc_get_card_table (int * shift_bits, void * * card_mask)
{
  guint8 * D.21605;

  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "boehm-gc.c", 1102);
  D.21605 = 0B;
  return D.21605;
}


mono_gc_card_table_nursery_check ()
{
  gboolean D.21607;

  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "boehm-gc.c", 1109);
  D.21607 = 1;
  return D.21607;
}


mono_gc_get_nursery (int * shift_bits, size_t * size)
{
  void * D.21609;

  D.21609 = 0B;
  return D.21609;
}


mono_gc_set_current_thread_appdomain (struct MonoDomain * domain)
{

}


mono_gc_precise_stack_mark_enabled ()
{
  gboolean D.21611;

  D.21611 = 0;
  return D.21611;
}


mono_gc_get_logfile ()
{
  struct FILE * D.21613;

  D.21613 = 0B;
  return D.21613;
}


mono_gc_conservatively_scan_area (void * start, void * end)
{
  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "boehm-gc.c", 1139);
}


mono_gc_scan_object (void * obj)
{
  void * D.21615;

  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "boehm-gc.c", 1145);
  D.21615 = 0B;
  return D.21615;
}


mono_gc_get_bitmap_for_descr (void * descr, int * numbits)
{
  gsize * D.21617;

  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "boehm-gc.c", 1152);
  D.21617 = 0B;
  return D.21617;
}


mono_gc_set_gc_callbacks (struct MonoGCCallbacks * callbacks)
{

}


mono_gc_set_stack_end (void * stack_end)
{

}


mono_gc_set_skip_thread (gboolean value)
{

}


mono_gc_register_for_finalization (struct MonoObject * obj, void * user_data)
{
  void * D.21619;
  sizetype D.21620;
  void * D.21621;
  _Bool D.21622;
  long int D.21623;
  long int D.21624;
  void * D.21627;
  void (*<T3216>) (void *, void *) user_data.22;
  void * offset.23;
  guint offset;

  offset = 0;
  D.21619 = GC_base (obj);
  D.21620 = -offset;
  D.21621 = obj + D.21620;
  D.21622 = D.21619 != D.21621;
  D.21623 = (long int) D.21622;
  D.21624 = __builtin_expect (D.21623, 0);
  if (D.21624 != 0) goto <D.21625>; else goto <D.21626>;
  <D.21625>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "boehm-gc.c", 1177, "GC_base (obj) == (char*)obj - offset");
  <D.21626>:
  D.21620 = -offset;
  D.21627 = obj + D.21620;
  user_data.22 = (void (*<T3216>) (void *, void *)) user_data;
  offset.23 = (void *) offset;
  GC_register_finalizer_no_order (D.21627, user_data.22, offset.23, 0B, 0B);
}


mono_gc_pthread_create (pthread_t * new_thread, const union pthread_attr_t * attr, void * (*<T1db5>) (void *) start_routine, void * arg)
{
  int D.21630;

  D.21630 = GC_pthread_create (new_thread, attr, start_routine, arg);
  return D.21630;
}


mono_gc_pthread_join (pthread_t thread, void * * retval)
{
  int D.21632;

  D.21632 = GC_pthread_join (thread, retval);
  return D.21632;
}


mono_gc_pthread_detach (pthread_t thread)
{
  int D.21634;

  D.21634 = GC_pthread_detach (thread);
  return D.21634;
}


mono_gc_pthread_exit (void * retval)
{
  pthread_exit (retval);
}


mono_gc_get_vtable_bits (struct MonoClass * class)
{
  guint D.21636;

  D.21636 = 0;
  return D.21636;
}


mono_gc_register_altstack (void * stack, gint32 stack_size, void * altstack, gint32 altstack_size)
{
  GC_register_altstack (stack, stack_size, altstack, altstack_size);
}


mono_gc_get_los_limit ()
{
  int D.21638;

  D.21638 = 2147483647;
  return D.21638;
}


mono_gc_user_markers_supported ()
{
  gboolean D.21640;

  D.21640 = 0;
  return D.21640;
}


mono_gc_make_root_descr_user (void (*MonoGCRootMarkFunc) (void *, void (*MonoGCMarkFunc) (void * *)) marker)
{
  void * D.21642;

  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "boehm-gc.c", 1261);
  D.21642 = 0B;
  return D.21642;
}


mono_gc_set_allow_synchronous_major (gboolean flag)
{
  gboolean D.21644;

  D.21644 = flag;
  return D.21644;
}