mono_gc_base_init ()
{
  int gc_initialized.0;
  long unsigned int D.18815;
  void * sstart.1;
  unsigned int size.2;
  char * GC_stackbottom.3;
  char * stack_bottom.4;
  int D.18825;
  char * D.18828;
  char D.18831;
  int D.18833;
  long int max_heap.5;
  struct _IO_FILE * stderr.6;
  long unsigned int max_heap.7;
  char * D.18840;
  struct MonoThreadInfoCallbacks cb;
  const char * env;

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

        try
          {
            D.18815 = pthread_self ();
            pthread_getattr_np (D.18815, &attr);
            pthread_attr_getstack (&attr, &sstart, &size);
            pthread_attr_destroy (&attr);
            sstart.1 = sstart;
            if (sstart.1 != 0B) goto <D.18817>; else goto <D.18818>;
            <D.18817>:
            sstart.1 = sstart;
            size.2 = size;
            GC_stackbottom.3 = sstart.1 + size.2;
            GC_stackbottom = GC_stackbottom.3;
            goto <D.18821>;
            <D.18818>:
            {
              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.18821>:
          }
        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.18823>; else goto <D.18824>;
      <D.18823>:
      {
        char * * ptr;
        char * * opts;

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

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

            try
              {
                D.18828 = __builtin_strchr (opt, 61);
                opt = D.18828 + 1;
                D.18831 = *opt;
                if (D.18831 != 0) goto <D.18832>; else goto <D.18829>;
                <D.18832>:
                D.18833 = mono_gc_parse_environment_string_extract_number (opt, &max_heap);
                if (D.18833 != 0) goto <D.18834>; else goto <D.18829>;
                <D.18834>:
                max_heap.5 = max_heap;
                if (max_heap.5 <= 16777215) goto <D.18836>; else goto <D.18837>;
                <D.18836>:
                stderr.6 = stderr;
                fprintf (stderr.6, "max-heap-size must be at least %dMb.\n", 16);
                exit (1);
                <D.18837>:
                max_heap.5 = max_heap;
                max_heap.7 = (long unsigned int) max_heap.5;
                GC_set_max_heap_size (max_heap.7);
                goto <D.18830>;
                <D.18829>:
                stderr.6 = stderr;
                fprintf (stderr.6, "max-heap-size must be an integer.\n");
                exit (1);
                <D.18830>:
                // predicted unlikely by continue predictor.
                goto <D.18516>;
              }
            finally
              {
                max_heap = {CLOBBER};
              }
          }
          <D.18827>:
        }
        <D.18516>:
        ptr = ptr + 4;
        <D.18518>:
        D.18840 = *ptr;
        if (D.18840 != 0B) goto <D.18517>; else goto <D.18519>;
        <D.18519>:
        monoeg_g_strfreev (opts);
      }
      <D.18824>:
      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, 392);
      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.18845;
  void * D.18848;
  void * iftmp.8;
  int D.18850;

  D.18845 = mono_gc_is_gc_thread ();
  if (D.18845 != 0) goto <D.18846>; else goto <D.18847>;
  <D.18846>:
  D.18848 = info;
  return D.18848;
  <D.18847>:
  D.18850 = GC_thread_register_foreign (baseptr);
  if (D.18850 != 0) goto <D.18851>; else goto <D.18852>;
  <D.18851>:
  iftmp.8 = info;
  goto <D.18853>;
  <D.18852>:
  iftmp.8 = 0B;
  <D.18853>:
  D.18848 = iftmp.8;
  return D.18848;
}


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.18855;

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


memset (void * __dest, int __ch, size_t __len)
{
  int D.18859;
  int D.18864;
  void * D.18866;
  unsigned int D.18867;

  D.18859 = __builtin_constant_p (__len);
  if (D.18859 != 0) goto <D.18860>; else goto <D.18861>;
  <D.18860>:
  if (__len == 0) goto <D.18862>; else goto <D.18863>;
  <D.18862>:
  D.18864 = __builtin_constant_p (__ch);
  if (D.18864 == 0) goto <D.18857>; else goto <D.18865>;
  <D.18865>:
  if (__ch != 0) goto <D.18857>; else goto <D.18858>;
  <D.18857>:
  __warn_memset_zero_len ();
  D.18866 = __dest;
  return D.18866;
  <D.18858>:
  <D.18863>:
  <D.18861>:
  D.18867 = __builtin_object_size (__dest, 0);
  D.18866 = __builtin___memset_chk (__dest, __ch, __len, D.18867);
  return D.18866;
}


mono_gc_collect (int generation)
{
  struct MonoPerfCounters * mono_perfcounters.9;
  unsigned int D.18870;
  unsigned int D.18871;

  mono_perfcounters.9 = mono_perfcounters;
  D.18870 = mono_perfcounters.9->gc_induced;
  D.18871 = D.18870 + 1;
  mono_perfcounters.9->gc_induced = D.18871;
  GC_gcollect ();
}


mono_gc_max_generation ()
{
  int D.18872;

  D.18872 = 0;
  return D.18872;
}


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

  D.18874 = 0;
  return D.18874;
}


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

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


mono_gc_add_memory_pressure (gint64 value)
{

}


mono_gc_get_used_size ()
{
  int64_t D.18879;
  unsigned int D.18880;
  unsigned int D.18881;
  unsigned int D.18882;

  D.18880 = GC_get_heap_size ();
  D.18881 = GC_get_free_bytes ();
  D.18882 = D.18880 - D.18881;
  D.18879 = (int64_t) D.18882;
  return D.18879;
}


mono_gc_get_heap_size ()
{
  int64_t D.18884;
  unsigned int D.18885;

  D.18885 = GC_get_heap_size ();
  D.18884 = (int64_t) D.18885;
  return D.18884;
}


mono_gc_is_gc_thread ()
{
  gboolean D.18887;

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


mono_gc_register_thread (void * baseptr)
{
  gboolean D.18889;
  struct MonoThreadInfo * D.18890;
  _Bool D.18891;

  D.18890 = mono_thread_info_attach (baseptr);
  D.18891 = D.18890 != 0B;
  D.18889 = (gboolean) D.18891;
  return D.18889;
}


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

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


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.18895;

  D.18895 = 1;
  return D.18895;
}


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.18897;
  struct MonoPerfCounters * mono_perfcounters.11;
  unsigned int D.18901;
  long long int D.18902;
  guint64 heap_size;

  D.18897 = GC_get_heap_size ();
  heap_size = (guint64) D.18897;
  mono_perfcounters.11 = mono_perfcounters;
  if (mono_perfcounters.11 != 0B) goto <D.18899>; else goto <D.18900>;
  <D.18899>:
  mono_perfcounters.11 = mono_perfcounters;
  D.18901 = (unsigned int) heap_size;
  mono_perfcounters.11->gc_committed_bytes = D.18901;
  mono_perfcounters.11 = mono_perfcounters;
  D.18901 = (unsigned int) heap_size;
  mono_perfcounters.11->gc_reserved_bytes = D.18901;
  mono_perfcounters.11 = mono_perfcounters;
  D.18901 = (unsigned int) heap_size;
  mono_perfcounters.11->gc_gen0size = D.18901;
  <D.18900>:
  D.18902 = (long long int) new_size;
  mono_profiler_gc_heap_resize (D.18902);
}


on_gc_notification (GCEventType event)
{
  struct MonoPerfCounters * mono_perfcounters.12;
  unsigned int D.18906;
  unsigned int D.18907;
  int D.18908;
  int D.18909;
  long long int gc_start_time.13;
  unsigned int D.18913;
  unsigned int D.18914;
  long long unsigned int D.18915;
  unsigned int D.18916;
  unsigned int D.18917;
  long long int D.18918;
  long long int gc_start_time.14;
  long long int D.18920;
  long long int D.18921;
  long long int D.18922;
  long long int D.18923;
  long long int D.18924;
  long long int D.18925;
  long long int D.18926;
  MonoGCEvent e;

  e = event;
  switch (e) <default: <D.18927>, case 0: <D.18571>, case 5: <D.18572>, case 6: <D.18566>, case 7: <D.18568>, case 8: <D.18569>, case 9: <D.18570>>
  <D.18566>:
  mono_thread_info_suspend_lock ();
  goto <D.18567>;
  <D.18568>:
  goto <D.18567>;
  <D.18569>:
  goto <D.18567>;
  <D.18570>:
  mono_thread_info_suspend_unlock ();
  goto <D.18567>;
  <D.18571>:
  mono_perfcounters.12 = mono_perfcounters;
  if (mono_perfcounters.12 != 0B) goto <D.18904>; else goto <D.18905>;
  <D.18904>:
  mono_perfcounters.12 = mono_perfcounters;
  D.18906 = mono_perfcounters.12->gc_collections0;
  D.18907 = D.18906 + 1;
  mono_perfcounters.12->gc_collections0 = D.18907;
  <D.18905>:
  D.18908 = gc_stats.major_gc_count;
  D.18909 = D.18908 + 1;
  gc_stats.major_gc_count = D.18909;
  gc_start_time.13 = mono_100ns_ticks ();
  gc_start_time = gc_start_time.13;
  goto <D.18567>;
  <D.18572>:
  mono_perfcounters.12 = mono_perfcounters;
  if (mono_perfcounters.12 != 0B) goto <D.18911>; else goto <D.18912>;
  <D.18911>:
  {
    guint64 heap_size;
    guint64 used_size;

    D.18913 = GC_get_heap_size ();
    heap_size = (guint64) D.18913;
    D.18914 = GC_get_free_bytes ();
    D.18915 = (long long unsigned int) D.18914;
    used_size = heap_size - D.18915;
    mono_perfcounters.12 = mono_perfcounters;
    D.18916 = (unsigned int) used_size;
    mono_perfcounters.12->gc_total_bytes = D.18916;
    mono_perfcounters.12 = mono_perfcounters;
    D.18917 = (unsigned int) heap_size;
    mono_perfcounters.12->gc_committed_bytes = D.18917;
    mono_perfcounters.12 = mono_perfcounters;
    D.18917 = (unsigned int) heap_size;
    mono_perfcounters.12->gc_reserved_bytes = D.18917;
    mono_perfcounters.12 = mono_perfcounters;
    D.18917 = (unsigned int) heap_size;
    mono_perfcounters.12->gc_gen0size = D.18917;
  }
  <D.18912>:
  D.18918 = mono_100ns_ticks ();
  gc_start_time.14 = gc_start_time;
  D.18920 = D.18918 - gc_start_time.14;
  D.18921 = D.18920 / 10;
  D.18922 = gc_stats.major_gc_time_usecs;
  D.18923 = D.18922 + D.18921;
  gc_stats.major_gc_time_usecs = D.18923;
  D.18924 = mono_100ns_ticks ();
  gc_start_time.14 = gc_start_time;
  D.18925 = D.18924 - gc_start_time.14;
  D.18926 = D.18925 / 10;
  mono_trace (32, 8, "gc took %d usecs", D.18926);
  goto <D.18567>;
  <D.18927>:
  <D.18567>:
  mono_profiler_gc_event (e, 0);
}


mono_gc_register_root (char * start, size_t size, void * descr)
{
  sizetype D.18928;
  char * D.18929;
  int D.18930;

  D.18928 = size + 1;
  D.18929 = start + D.18928;
  GC_add_roots (start, D.18929);
  D.18930 = 1;
  return D.18930;
}


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

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


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

  obj.15 = (long unsigned int) obj;
  D.18934 = ~obj.15;
  D.18935 = (void *) D.18934;
  *link_addr = D.18935;
  if (track != 0) goto <D.18936>; else goto <D.18937>;
  <D.18936>:
  GC_register_long_link (link_addr, obj);
  goto <D.18938>;
  <D.18937>:
  GC_general_register_disappearing_link (link_addr, obj);
  <D.18938>:
}


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


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

  obj = GC_call_with_alloc_lock (reveal_link, link_addr);
  if (obj == 4294967295B) goto <D.18942>; else goto <D.18943>;
  <D.18942>:
  D.18944 = 0B;
  return D.18944;
  <D.18943>:
  D.18944 = obj;
  return D.18944;
}


reveal_link (void * link_addr)
{
  void * D.18946;
  void * D.18947;
  long unsigned int D.18948;
  long unsigned int D.18949;
  void * * link_a;

  link_a = link_addr;
  D.18947 = *link_a;
  D.18948 = (long unsigned int) D.18947;
  D.18949 = ~D.18948;
  D.18946 = (void *) D.18949;
  return D.18946;
}


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

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


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

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


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

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


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

  if (numbits > 29) goto <D.18957>; else goto <D.18958>;
  <D.18957>:
  D.18959 = 0B;
  return D.18959;
  <D.18958>:
  numbits.16 = (unsigned int) numbits;
  D.18961 = GC_make_descriptor (bitmap, numbits.16);
  D.18959 = (void *) D.18961;
  return D.18959;
}


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

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


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

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


mono_gc_free_fixed (void * addr)
{

}


mono_gc_invoke_finalizers ()
{
  int D.18970;
  int D.18973;

  D.18970 = GC_should_invoke_finalizers ();
  if (D.18970 != 0) goto <D.18971>; else goto <D.18972>;
  <D.18971>:
  D.18973 = GC_invoke_finalizers ();
  return D.18973;
  <D.18972>:
  D.18973 = 0;
  return D.18973;
}


mono_gc_pending_finalizers ()
{
  gboolean D.18975;

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


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.18978;

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


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.18981;
  void * D.18982;
  void * D.18983;
  void * old_val;

  <D.17587>:
  old_val = *val;
  old_val.19 = (unsigned int) old_val;
  new_val.20 = (unsigned int) new_val;
  D.18981 = __sync_val_compare_and_swap_4 (val, old_val.19, new_val.20);
  D.18982 = (void *) D.18981;
  if (D.18982 != old_val) goto <D.17587>; else goto <D.17588>;
  <D.17588>:
  D.18983 = old_val;
  return D.18983;
}


mono_gc_wbarrier_generic_nostore (void * ptr)
{

}


mono_gc_wbarrier_value_copy (void * dest, void * src, int count, struct MonoClass * klass)
{
  int D.18985;
  int D.18986;
  unsigned int D.18987;

  D.18985 = mono_class_value_size (klass, 0B);
  D.18986 = D.18985 * count;
  D.18987 = (unsigned int) D.18986;
  mono_gc_memmove_atomic (dest, src, D.18987);
}


mono_gc_wbarrier_object_copy (struct MonoObject * obj, struct MonoObject * src)
{
  void * D.18988;
  const void * D.18989;
  struct MonoVTable * D.18990;
  struct MonoClass * D.18991;
  int D.18992;
  unsigned int D.18993;
  unsigned int D.18994;

  D.18988 = obj + 8;
  D.18989 = src + 8;
  D.18990 = obj->vtable;
  D.18991 = D.18990->klass;
  D.18992 = D.18991->instance_size;
  D.18993 = (unsigned int) D.18992;
  D.18994 = D.18993 + 4294967288;
  mono_gc_memmove_aligned (D.18988, D.18989, D.18994);
}


mono_gc_clear_domain (struct MonoDomain * domain)
{

}


mono_gc_get_suspend_signal ()
{
  int D.18995;

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


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

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


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

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


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

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


mono_gc_get_managed_allocator_types ()
{
  guint32 D.19003;

  D.19003 = 0;
  return D.19003;
}


mono_gc_get_write_barrier ()
{
  struct MonoMethod * D.19005;

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


mono_gc_get_gc_name ()
{
  const char * D.19007;

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


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

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


mono_gc_get_description ()
{
  char * D.19011;

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


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

  if (str != 0B) goto <D.19013>; else goto <D.19014>;
  <D.19013>:
  D.19015 = __strdup (str);
  return D.19015;
  <D.19014>:
  D.19015 = 0B;
  return D.19015;
}


mono_gc_set_desktop_mode ()
{
  GC_dont_expand = 1;
}


mono_gc_is_moving ()
{
  gboolean D.19017;

  D.19017 = 0;
  return D.19017;
}


mono_gc_is_disabled ()
{
  int GC_dont_gc.21;
  const gchar * D.19023;
  gboolean D.19024;

  GC_dont_gc.21 = GC_dont_gc;
  if (GC_dont_gc.21 != 0) goto <D.19019>; else goto <D.19022>;
  <D.19022>:
  D.19023 = monoeg_g_getenv ("GC_DONT_GC");
  if (D.19023 != 0B) goto <D.19019>; else goto <D.19020>;
  <D.19019>:
  D.19024 = 1;
  return D.19024;
  <D.19020>:
  D.19024 = 0;
  return D.19024;
}


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.19026;

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


mono_gc_card_table_nursery_check ()
{
  gboolean D.19028;

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


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

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


mono_gc_set_current_thread_appdomain (struct MonoDomain * domain)
{

}


mono_gc_precise_stack_mark_enabled ()
{
  gboolean D.19032;

  D.19032 = 0;
  return D.19032;
}


mono_gc_get_logfile ()
{
  struct FILE * D.19034;

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


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.19036;

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


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

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


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.19040;
  sizetype D.19041;
  void * D.19042;
  _Bool D.19043;
  long int D.19044;
  long int D.19045;
  void * D.19048;
  void (*<T27a5>) (void *, void *) user_data.22;
  void * offset.23;
  guint offset;

  offset = 0;
  D.19040 = GC_base (obj);
  D.19041 = -offset;
  D.19042 = obj + D.19041;
  D.19043 = D.19040 != D.19042;
  D.19044 = (long int) D.19043;
  D.19045 = __builtin_expect (D.19044, 0);
  if (D.19045 != 0) goto <D.19046>; else goto <D.19047>;
  <D.19046>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "boehm-gc.c", 1177, "GC_base (obj) == (char*)obj - offset");
  <D.19047>:
  D.19041 = -offset;
  D.19048 = obj + D.19041;
  user_data.22 = (void (*<T27a5>) (void *, void *)) user_data;
  offset.23 = (void *) offset;
  GC_register_finalizer_no_order (D.19048, user_data.22, offset.23, 0B, 0B);
}


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

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


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

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


mono_gc_pthread_detach (pthread_t thread)
{
  int D.19055;

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


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


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

  D.19057 = 0;
  return D.19057;
}


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.19059;

  D.19059 = 2147483647;
  return D.19059;
}


mono_gc_user_markers_supported ()
{
  gboolean D.19061;

  D.19061 = 0;
  return D.19061;
}


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

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


mono_gc_set_allow_synchronous_major (gboolean flag)
{
  gboolean D.19065;

  D.19065 = flag;
  return D.19065;
}