mono_gc_base_init ()
{
  int gc_initialized.0;
  long unsigned int D.19710;
  void * sstart.1;
  long unsigned int size.2;
  char * GC_stackbottom.3;
  char * stack_bottom.4;
  int D.19720;
  char * D.19723;
  char D.19726;
  int D.19728;
  long int max_heap.5;
  struct _IO_FILE * stderr.6;
  long unsigned int max_heap.7;
  char * D.19735;
  struct MonoThreadInfoCallbacks cb;
  const char * env;

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

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

              try
                {
                  stack_bottom = (gsize) &dummy;
                  stack_bottom = stack_bottom + 4095;
                  stack_bottom = stack_bottom & 18446744073709547520;
                  stack_bottom.4 = (char *) stack_bottom;
                  GC_stackbottom = stack_bottom.4;
                }
              finally
                {
                  dummy = {CLOBBER};
                }
            }
            <D.19716>:
          }
        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.19718>; else goto <D.19719>;
      <D.19718>:
      {
        char * * ptr;
        char * * opts;

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

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

            try
              {
                D.19723 = __builtin_strchr (opt, 61);
                opt = D.19723 + 1;
                D.19726 = *opt;
                if (D.19726 != 0) goto <D.19727>; else goto <D.19724>;
                <D.19727>:
                D.19728 = mono_gc_parse_environment_string_extract_number (opt, &max_heap);
                if (D.19728 != 0) goto <D.19729>; else goto <D.19724>;
                <D.19729>:
                max_heap.5 = max_heap;
                if (max_heap.5 <= 16777215) goto <D.19731>; else goto <D.19732>;
                <D.19731>:
                stderr.6 = stderr;
                fprintf (stderr.6, "max-heap-size must be at least %dMb.\n", 16);
                exit (1);
                <D.19732>:
                max_heap.5 = max_heap;
                max_heap.7 = (long unsigned int) max_heap.5;
                GC_set_max_heap_size (max_heap.7);
                goto <D.19725>;
                <D.19724>:
                stderr.6 = stderr;
                fprintf (stderr.6, "max-heap-size must be an integer.\n");
                exit (1);
                <D.19725>:
                // predicted unlikely by continue predictor.
                goto <D.19411>;
              }
            finally
              {
                max_heap = {CLOBBER};
              }
          }
          <D.19722>:
        }
        <D.19411>:
        ptr = ptr + 8;
        <D.19413>:
        D.19735 = *ptr;
        if (D.19735 != 0B) goto <D.19412>; else goto <D.19414>;
        <D.19414>:
        monoeg_g_strfreev (opts);
      }
      <D.19719>:
      memset (&cb, 0, 48);
      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, 544);
      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.19740;
  void * D.19743;
  void * iftmp.8;
  int D.19745;

  D.19740 = mono_gc_is_gc_thread ();
  if (D.19740 != 0) goto <D.19741>; else goto <D.19742>;
  <D.19741>:
  D.19743 = info;
  return D.19743;
  <D.19742>:
  D.19745 = GC_thread_register_foreign (baseptr);
  if (D.19745 != 0) goto <D.19746>; else goto <D.19747>;
  <D.19746>:
  iftmp.8 = info;
  goto <D.19748>;
  <D.19747>:
  iftmp.8 = 0B;
  <D.19748>:
  D.19743 = iftmp.8;
  return D.19743;
}


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

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


memset (void * __dest, int __ch, size_t __len)
{
  int D.19754;
  int D.19759;
  void * D.19761;
  long unsigned int D.19762;

  D.19754 = __builtin_constant_p (__len);
  if (D.19754 != 0) goto <D.19755>; else goto <D.19756>;
  <D.19755>:
  if (__len == 0) goto <D.19757>; else goto <D.19758>;
  <D.19757>:
  D.19759 = __builtin_constant_p (__ch);
  if (D.19759 == 0) goto <D.19752>; else goto <D.19760>;
  <D.19760>:
  if (__ch != 0) goto <D.19752>; else goto <D.19753>;
  <D.19752>:
  __warn_memset_zero_len ();
  D.19761 = __dest;
  return D.19761;
  <D.19753>:
  <D.19758>:
  <D.19756>:
  D.19762 = __builtin_object_size (__dest, 0);
  D.19761 = __builtin___memset_chk (__dest, __ch, __len, D.19762);
  return D.19761;
}


mono_gc_collect (int generation)
{
  struct MonoPerfCounters * mono_perfcounters.9;
  unsigned int D.19765;
  unsigned int D.19766;

  mono_perfcounters.9 = mono_perfcounters;
  D.19765 = mono_perfcounters.9->gc_induced;
  D.19766 = D.19765 + 1;
  mono_perfcounters.9->gc_induced = D.19766;
  GC_gcollect ();
}


mono_gc_max_generation ()
{
  int D.19767;

  D.19767 = 0;
  return D.19767;
}


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

  D.19769 = 0;
  return D.19769;
}


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

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


mono_gc_add_memory_pressure (gint64 value)
{

}


mono_gc_get_used_size ()
{
  int64_t D.19774;
  long unsigned int D.19775;
  long unsigned int D.19776;
  long unsigned int D.19777;

  D.19775 = GC_get_heap_size ();
  D.19776 = GC_get_free_bytes ();
  D.19777 = D.19775 - D.19776;
  D.19774 = (int64_t) D.19777;
  return D.19774;
}


mono_gc_get_heap_size ()
{
  int64_t D.19779;
  long unsigned int D.19780;

  D.19780 = GC_get_heap_size ();
  D.19779 = (int64_t) D.19780;
  return D.19779;
}


mono_gc_is_gc_thread ()
{
  gboolean D.19782;

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


mono_gc_register_thread (void * baseptr)
{
  gboolean D.19784;
  struct MonoThreadInfo * D.19785;
  _Bool D.19786;

  D.19785 = mono_thread_info_attach (baseptr);
  D.19786 = D.19785 != 0B;
  D.19784 = (gboolean) D.19786;
  return D.19784;
}


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

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


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

  D.19790 = 1;
  return D.19790;
}


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)
{
  struct MonoPerfCounters * mono_perfcounters.11;
  unsigned int D.19795;
  long int new_size.12;
  guint64 heap_size;

  heap_size = GC_get_heap_size ();
  mono_perfcounters.11 = mono_perfcounters;
  if (mono_perfcounters.11 != 0B) goto <D.19793>; else goto <D.19794>;
  <D.19793>:
  mono_perfcounters.11 = mono_perfcounters;
  D.19795 = (unsigned int) heap_size;
  mono_perfcounters.11->gc_committed_bytes = D.19795;
  mono_perfcounters.11 = mono_perfcounters;
  D.19795 = (unsigned int) heap_size;
  mono_perfcounters.11->gc_reserved_bytes = D.19795;
  mono_perfcounters.11 = mono_perfcounters;
  D.19795 = (unsigned int) heap_size;
  mono_perfcounters.11->gc_gen0size = D.19795;
  <D.19794>:
  new_size.12 = (long int) new_size;
  mono_profiler_gc_heap_resize (new_size.12);
}


on_gc_notification (GCEventType event)
{
  struct MonoPerfCounters * mono_perfcounters.13;
  unsigned int D.19800;
  unsigned int D.19801;
  int D.19802;
  int D.19803;
  long int gc_start_time.14;
  long unsigned int D.19807;
  unsigned int D.19808;
  unsigned int D.19809;
  long int D.19810;
  long int gc_start_time.15;
  long int D.19812;
  long int D.19813;
  long long int D.19814;
  long long int D.19815;
  long int D.19816;
  long int D.19817;
  long int D.19818;
  MonoGCEvent e;

  e = event;
  switch (e) <default: <D.19819>, case 0: <D.19466>, case 5: <D.19467>, case 6: <D.19461>, case 7: <D.19463>, case 8: <D.19464>, case 9: <D.19465>>
  <D.19461>:
  mono_thread_info_suspend_lock ();
  goto <D.19462>;
  <D.19463>:
  goto <D.19462>;
  <D.19464>:
  goto <D.19462>;
  <D.19465>:
  mono_thread_info_suspend_unlock ();
  goto <D.19462>;
  <D.19466>:
  mono_perfcounters.13 = mono_perfcounters;
  if (mono_perfcounters.13 != 0B) goto <D.19798>; else goto <D.19799>;
  <D.19798>:
  mono_perfcounters.13 = mono_perfcounters;
  D.19800 = mono_perfcounters.13->gc_collections0;
  D.19801 = D.19800 + 1;
  mono_perfcounters.13->gc_collections0 = D.19801;
  <D.19799>:
  D.19802 = gc_stats.major_gc_count;
  D.19803 = D.19802 + 1;
  gc_stats.major_gc_count = D.19803;
  gc_start_time.14 = mono_100ns_ticks ();
  gc_start_time = gc_start_time.14;
  goto <D.19462>;
  <D.19467>:
  mono_perfcounters.13 = mono_perfcounters;
  if (mono_perfcounters.13 != 0B) goto <D.19805>; else goto <D.19806>;
  <D.19805>:
  {
    guint64 heap_size;
    guint64 used_size;

    heap_size = GC_get_heap_size ();
    D.19807 = GC_get_free_bytes ();
    used_size = heap_size - D.19807;
    mono_perfcounters.13 = mono_perfcounters;
    D.19808 = (unsigned int) used_size;
    mono_perfcounters.13->gc_total_bytes = D.19808;
    mono_perfcounters.13 = mono_perfcounters;
    D.19809 = (unsigned int) heap_size;
    mono_perfcounters.13->gc_committed_bytes = D.19809;
    mono_perfcounters.13 = mono_perfcounters;
    D.19809 = (unsigned int) heap_size;
    mono_perfcounters.13->gc_reserved_bytes = D.19809;
    mono_perfcounters.13 = mono_perfcounters;
    D.19809 = (unsigned int) heap_size;
    mono_perfcounters.13->gc_gen0size = D.19809;
  }
  <D.19806>:
  D.19810 = mono_100ns_ticks ();
  gc_start_time.15 = gc_start_time;
  D.19812 = D.19810 - gc_start_time.15;
  D.19813 = D.19812 / 10;
  D.19814 = gc_stats.major_gc_time_usecs;
  D.19815 = D.19814 + D.19813;
  gc_stats.major_gc_time_usecs = D.19815;
  D.19816 = mono_100ns_ticks ();
  gc_start_time.15 = gc_start_time;
  D.19817 = D.19816 - gc_start_time.15;
  D.19818 = D.19817 / 10;
  mono_trace (32, 8, "gc took %d usecs", D.19818);
  goto <D.19462>;
  <D.19819>:
  <D.19462>:
  mono_profiler_gc_event (e, 0);
}


mono_gc_register_root (char * start, size_t size, void * descr)
{
  sizetype D.19820;
  char * D.19821;
  int D.19822;

  D.19820 = size + 1;
  D.19821 = start + D.19820;
  GC_add_roots (start, D.19821);
  D.19822 = 1;
  return D.19822;
}


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

  D.19824 = addr + 9;
  GC_remove_roots (addr, D.19824);
}


mono_gc_weak_link_add (void * * link_addr, struct MonoObject * obj, gboolean track)
{
  long unsigned int obj.16;
  long unsigned int D.19826;
  void * D.19827;

  obj.16 = (long unsigned int) obj;
  D.19826 = ~obj.16;
  D.19827 = (void *) D.19826;
  *link_addr = D.19827;
  if (track != 0) goto <D.19828>; else goto <D.19829>;
  <D.19828>:
  GC_register_long_link (link_addr, obj);
  goto <D.19830>;
  <D.19829>:
  GC_general_register_disappearing_link (link_addr, obj);
  <D.19830>:
}


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


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

  obj = GC_call_with_alloc_lock (reveal_link, link_addr);
  if (obj == -1B) goto <D.19834>; else goto <D.19835>;
  <D.19834>:
  D.19836 = 0B;
  return D.19836;
  <D.19835>:
  D.19836 = obj;
  return D.19836;
}


reveal_link (void * link_addr)
{
  void * D.19838;
  void * D.19839;
  long unsigned int D.19840;
  long unsigned int D.19841;
  void * * link_a;

  link_a = link_addr;
  D.19839 = *link_a;
  D.19840 = (long unsigned int) D.19839;
  D.19841 = ~D.19840;
  D.19838 = (void *) D.19841;
  return D.19838;
}


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

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


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

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


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

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


mono_gc_make_descr_from_bitmap (gsize * bitmap, int numbits)
{
  void * D.19851;
  long unsigned int D.19852;
  long unsigned int D.19853;

  if (numbits > 29) goto <D.19849>; else goto <D.19850>;
  <D.19849>:
  D.19851 = 0B;
  return D.19851;
  <D.19850>:
  D.19852 = (long unsigned int) numbits;
  D.19853 = GC_make_descriptor (bitmap, D.19852);
  D.19851 = (void *) D.19853;
  return D.19851;
}


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

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


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

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


mono_gc_free_fixed (void * addr)
{

}


mono_gc_invoke_finalizers ()
{
  int D.19862;
  int D.19865;

  D.19862 = GC_should_invoke_finalizers ();
  if (D.19862 != 0) goto <D.19863>; else goto <D.19864>;
  <D.19863>:
  D.19865 = GC_invoke_finalizers ();
  return D.19865;
  <D.19864>:
  D.19865 = 0;
  return D.19865;
}


mono_gc_pending_finalizers ()
{
  gboolean D.19867;

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


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)
{
  long unsigned int D.19869;
  long unsigned int D.19870;

  D.19869 = (long unsigned int) count;
  D.19870 = D.19869 * 8;
  mono_gc_memmove_aligned (dest_ptr, src_ptr, D.19870);
}


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)
{
  long unsigned int old_val.18;
  long unsigned int new_val.19;
  long unsigned int D.19873;
  void * D.19874;
  void * D.19875;
  void * old_val;

  <D.18515>:
  old_val = *val;
  old_val.18 = (long unsigned int) old_val;
  new_val.19 = (long unsigned int) new_val;
  D.19873 = __sync_val_compare_and_swap_8 (val, old_val.18, new_val.19);
  D.19874 = (void *) D.19873;
  if (D.19874 != old_val) goto <D.18515>; else goto <D.18516>;
  <D.18516>:
  D.19875 = old_val;
  return D.19875;
}


mono_gc_wbarrier_generic_nostore (void * ptr)
{

}


mono_gc_wbarrier_value_copy (void * dest, void * src, int count, struct MonoClass * klass)
{
  int D.19877;
  int D.19878;
  long unsigned int D.19879;

  D.19877 = mono_class_value_size (klass, 0B);
  D.19878 = D.19877 * count;
  D.19879 = (long unsigned int) D.19878;
  mono_gc_memmove_atomic (dest, src, D.19879);
}


mono_gc_wbarrier_object_copy (struct MonoObject * obj, struct MonoObject * src)
{
  void * D.19880;
  const void * D.19881;
  struct MonoVTable * D.19882;
  struct MonoClass * D.19883;
  int D.19884;
  long unsigned int D.19885;
  long unsigned int D.19886;

  D.19880 = obj + 16;
  D.19881 = src + 16;
  D.19882 = obj->vtable;
  D.19883 = D.19882->klass;
  D.19884 = D.19883->instance_size;
  D.19885 = (long unsigned int) D.19884;
  D.19886 = D.19885 + 18446744073709551600;
  mono_gc_memmove_aligned (D.19880, D.19881, D.19886);
}


mono_gc_clear_domain (struct MonoDomain * domain)
{

}


mono_gc_get_suspend_signal ()
{
  int D.19887;

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


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

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


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

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


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

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


mono_gc_get_managed_allocator_types ()
{
  guint32 D.19895;

  D.19895 = 0;
  return D.19895;
}


mono_gc_get_write_barrier ()
{
  struct MonoMethod * D.19897;

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


mono_gc_get_gc_name ()
{
  const char * D.19899;

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


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

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


mono_gc_get_description ()
{
  char * D.19903;

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


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

  if (str != 0B) goto <D.19905>; else goto <D.19906>;
  <D.19905>:
  D.19907 = __strdup (str);
  return D.19907;
  <D.19906>:
  D.19907 = 0B;
  return D.19907;
}


mono_gc_set_desktop_mode ()
{
  GC_dont_expand = 1;
}


mono_gc_is_moving ()
{
  gboolean D.19909;

  D.19909 = 0;
  return D.19909;
}


mono_gc_is_disabled ()
{
  int GC_dont_gc.20;
  const gchar * D.19915;
  gboolean D.19916;

  GC_dont_gc.20 = GC_dont_gc;
  if (GC_dont_gc.20 != 0) goto <D.19911>; else goto <D.19914>;
  <D.19914>:
  D.19915 = monoeg_g_getenv ("GC_DONT_GC");
  if (D.19915 != 0B) goto <D.19911>; else goto <D.19912>;
  <D.19911>:
  D.19916 = 1;
  return D.19916;
  <D.19912>:
  D.19916 = 0;
  return D.19916;
}


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

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


mono_gc_card_table_nursery_check ()
{
  gboolean D.19920;

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


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

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


mono_gc_set_current_thread_appdomain (struct MonoDomain * domain)
{

}


mono_gc_precise_stack_mark_enabled ()
{
  gboolean D.19924;

  D.19924 = 0;
  return D.19924;
}


mono_gc_get_logfile ()
{
  struct FILE * D.19926;

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


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

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


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

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


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.19932;
  sizetype D.19933;
  sizetype D.19934;
  void * D.19935;
  _Bool D.19936;
  long int D.19937;
  long int D.19938;
  void * D.19941;
  void (*<T28dd>) (void *, void *) user_data.21;
  long unsigned int D.19943;
  void * D.19944;
  guint offset;

  offset = 0;
  D.19932 = GC_base (obj);
  D.19933 = (sizetype) offset;
  D.19934 = -D.19933;
  D.19935 = obj + D.19934;
  D.19936 = D.19932 != D.19935;
  D.19937 = (long int) D.19936;
  D.19938 = __builtin_expect (D.19937, 0);
  if (D.19938 != 0) goto <D.19939>; else goto <D.19940>;
  <D.19939>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "boehm-gc.c", 1177, "GC_base (obj) == (char*)obj - offset");
  <D.19940>:
  D.19933 = (sizetype) offset;
  D.19934 = -D.19933;
  D.19941 = obj + D.19934;
  user_data.21 = (void (*<T28dd>) (void *, void *)) user_data;
  D.19943 = (long unsigned int) offset;
  D.19944 = (void *) D.19943;
  GC_register_finalizer_no_order (D.19941, user_data.21, D.19944, 0B, 0B);
}


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

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


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

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


mono_gc_pthread_detach (pthread_t thread)
{
  int D.19949;

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


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


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

  D.19951 = 0;
  return D.19951;
}


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

  D.19953 = 2147483647;
  return D.19953;
}


mono_gc_user_markers_supported ()
{
  gboolean D.19955;

  D.19955 = 0;
  return D.19955;
}


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

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


mono_gc_set_allow_synchronous_major (gboolean flag)
{
  gboolean D.19959;

  D.19959 = flag;
  return D.19959;
}