__attribute__((visibility ("hidden")))
mono_gc_base_init ()
{
  int gc_initialized.0;
  long unsigned int D.19346;
  void * sstart.1;
  long unsigned int size.2;
  char * D.19351;
  char * stack_bottom.3;
  int D.19356;
  char * D.19359;
  char D.19362;
  int D.19364;
  long int max_heap.4;
  struct _IO_FILE * stderr.5;
  long unsigned int max_heap.6;
  char * D.19371;
  struct MonoThreadInfoCallbacks cb;
  const char * env;

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

        try
          {
            D.19346 = pthread_self ();
            pthread_getattr_np (D.19346, &attr);
            pthread_attr_getstack (&attr, &sstart, &size);
            pthread_attr_destroy (&attr);
            sstart.1 = sstart;
            if (sstart.1 != 0B) goto <D.19348>; else goto <D.19349>;
            <D.19348>:
            sstart.1 = sstart;
            size.2 = size;
            D.19351 = sstart.1 + size.2;
            GC_stackbottom = D.19351;
            goto <D.19352>;
            <D.19349>:
            {
              int dummy;
              gsize stack_bottom;

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

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

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

            try
              {
                D.19359 = __builtin_strchr (opt, 61);
                opt = D.19359 + 1;
                D.19362 = *opt;
                if (D.19362 != 0) goto <D.19363>; else goto <D.19360>;
                <D.19363>:
                D.19364 = mono_gc_parse_environment_string_extract_number (opt, &max_heap);
                if (D.19364 != 0) goto <D.19365>; else goto <D.19360>;
                <D.19365>:
                max_heap.4 = max_heap;
                if (max_heap.4 <= 16777215) goto <D.19367>; else goto <D.19368>;
                <D.19367>:
                stderr.5 = stderr;
                fprintf (stderr.5, "max-heap-size must be at least %dMb.\n", 16);
                exit (1);
                <D.19368>:
                max_heap.4 = max_heap;
                max_heap.6 = (long unsigned int) max_heap.4;
                GC_set_max_heap_size (max_heap.6);
                goto <D.19361>;
                <D.19360>:
                stderr.5 = stderr;
                fprintf (stderr.5, "max-heap-size must be an integer.\n");
                exit (1);
                <D.19361>:
                // predicted unlikely by continue predictor.
                goto <D.19047>;
              }
            finally
              {
                max_heap = {CLOBBER};
              }
          }
          <D.19358>:
        }
        <D.19047>:
        ptr = ptr + 8;
        <D.19049>:
        D.19371 = *ptr;
        if (D.19371 != 0B) goto <D.19048>; else goto <D.19050>;
        <D.19050>:
        monoeg_g_strfreev (opts);
      }
      <D.19355>:
      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, 744);
      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.19376;
  void * D.19379;
  void * iftmp.7;
  int D.19381;

  D.19376 = mono_gc_is_gc_thread ();
  if (D.19376 != 0) goto <D.19377>; else goto <D.19378>;
  <D.19377>:
  D.19379 = info;
  return D.19379;
  <D.19378>:
  D.19381 = GC_thread_register_foreign (baseptr);
  if (D.19381 != 0) goto <D.19382>; else goto <D.19383>;
  <D.19382>:
  iftmp.7 = info;
  goto <D.19384>;
  <D.19383>:
  iftmp.7 = 0B;
  <D.19384>:
  D.19379 = iftmp.7;
  return D.19379;
}


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


__attribute__((__artificial__, __gnu_inline__, __always_inline__))
fprintf (struct FILE * restrict __stream, const char * restrict __fmt)
{
  int D.19386;

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


__attribute__((__artificial__, __gnu_inline__, __always_inline__, __nothrow__, __leaf__))
memset (void * __dest, int __ch, size_t __len)
{
  void * D.19388;
  long unsigned int D.19389;

  D.19389 = __builtin_object_size (__dest, 0);
  D.19388 = __builtin___memset_chk (__dest, __ch, __len, D.19389);
  return D.19388;
}


mono_gc_collect (int generation)
{
  struct MonoPerfCounters * mono_perfcounters.8;
  unsigned int D.19392;
  unsigned int D.19393;

  mono_perfcounters.8 = mono_perfcounters;
  D.19392 = mono_perfcounters.8->gc_induced;
  D.19393 = D.19392 + 1;
  mono_perfcounters.8->gc_induced = D.19393;
  GC_gcollect ();
}


mono_gc_max_generation ()
{
  int D.19394;

  D.19394 = 0;
  return D.19394;
}


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

  D.19396 = 0;
  return D.19396;
}


mono_gc_collection_count (int generation)
{
  int D.19398;
  long unsigned int GC_gc_no.9;

  GC_gc_no.9 = GC_gc_no;
  D.19398 = (int) GC_gc_no.9;
  return D.19398;
}


__attribute__((visibility ("hidden")))
mono_gc_add_memory_pressure (gint64 value)
{

}


mono_gc_get_used_size ()
{
  int64_t D.19401;
  long unsigned int D.19402;
  long unsigned int D.19403;
  long unsigned int D.19404;

  D.19402 = GC_get_heap_size ();
  D.19403 = GC_get_free_bytes ();
  D.19404 = D.19402 - D.19403;
  D.19401 = (int64_t) D.19404;
  return D.19401;
}


mono_gc_get_heap_size ()
{
  int64_t D.19406;
  long unsigned int D.19407;

  D.19407 = GC_get_heap_size ();
  D.19406 = (int64_t) D.19407;
  return D.19406;
}


__attribute__((visibility ("hidden")))
mono_gc_is_gc_thread ()
{
  gboolean D.19409;

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


__attribute__((visibility ("hidden")))
mono_gc_register_thread (void * baseptr)
{
  gboolean D.19411;
  struct MonoThreadInfo * D.19412;
  _Bool D.19413;

  D.19412 = mono_thread_info_attach (baseptr);
  D.19413 = D.19412 != 0B;
  D.19411 = (gboolean) D.19413;
  return D.19411;
}


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

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


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

  D.19417 = 1;
  return D.19417;
}


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.10;
  unsigned int D.19422;
  long int new_size.11;
  guint64 heap_size;

  heap_size = GC_get_heap_size ();
  mono_perfcounters.10 = mono_perfcounters;
  if (mono_perfcounters.10 != 0B) goto <D.19420>; else goto <D.19421>;
  <D.19420>:
  mono_perfcounters.10 = mono_perfcounters;
  D.19422 = (unsigned int) heap_size;
  mono_perfcounters.10->gc_committed_bytes = D.19422;
  mono_perfcounters.10 = mono_perfcounters;
  D.19422 = (unsigned int) heap_size;
  mono_perfcounters.10->gc_reserved_bytes = D.19422;
  mono_perfcounters.10 = mono_perfcounters;
  D.19422 = (unsigned int) heap_size;
  mono_perfcounters.10->gc_gen0size = D.19422;
  <D.19421>:
  new_size.11 = (long int) new_size;
  mono_profiler_gc_heap_resize (new_size.11);
}


on_gc_notification (GCEventType event)
{
  struct MonoPerfCounters * mono_perfcounters.12;
  unsigned int D.19427;
  unsigned int D.19428;
  int D.19429;
  int D.19430;
  long int D.19431;
  long unsigned int D.19434;
  unsigned int D.19435;
  unsigned int D.19436;
  long int D.19437;
  long int gc_start_time.13;
  long int D.19439;
  long int D.19440;
  long long int D.19441;
  long long int D.19442;
  long int D.19443;
  long int D.19444;
  long int D.19445;
  MonoGCEvent e;

  e = event;
  switch (e) <default: <D.19446>, case 0: <D.19102>, case 5: <D.19103>, case 6: <D.19097>, case 7: <D.19099>, case 8: <D.19100>, case 9: <D.19101>>
  <D.19097>:
  mono_thread_info_suspend_lock ();
  goto <D.19098>;
  <D.19099>:
  goto <D.19098>;
  <D.19100>:
  goto <D.19098>;
  <D.19101>:
  mono_thread_info_suspend_unlock ();
  goto <D.19098>;
  <D.19102>:
  mono_perfcounters.12 = mono_perfcounters;
  if (mono_perfcounters.12 != 0B) goto <D.19425>; else goto <D.19426>;
  <D.19425>:
  mono_perfcounters.12 = mono_perfcounters;
  D.19427 = mono_perfcounters.12->gc_collections0;
  D.19428 = D.19427 + 1;
  mono_perfcounters.12->gc_collections0 = D.19428;
  <D.19426>:
  D.19429 = gc_stats.major_gc_count;
  D.19430 = D.19429 + 1;
  gc_stats.major_gc_count = D.19430;
  D.19431 = mono_100ns_ticks ();
  gc_start_time = D.19431;
  goto <D.19098>;
  <D.19103>:
  mono_perfcounters.12 = mono_perfcounters;
  if (mono_perfcounters.12 != 0B) goto <D.19432>; else goto <D.19433>;
  <D.19432>:
  {
    guint64 heap_size;
    guint64 used_size;

    heap_size = GC_get_heap_size ();
    D.19434 = GC_get_free_bytes ();
    used_size = heap_size - D.19434;
    mono_perfcounters.12 = mono_perfcounters;
    D.19435 = (unsigned int) used_size;
    mono_perfcounters.12->gc_total_bytes = D.19435;
    mono_perfcounters.12 = mono_perfcounters;
    D.19436 = (unsigned int) heap_size;
    mono_perfcounters.12->gc_committed_bytes = D.19436;
    mono_perfcounters.12 = mono_perfcounters;
    D.19436 = (unsigned int) heap_size;
    mono_perfcounters.12->gc_reserved_bytes = D.19436;
    mono_perfcounters.12 = mono_perfcounters;
    D.19436 = (unsigned int) heap_size;
    mono_perfcounters.12->gc_gen0size = D.19436;
  }
  <D.19433>:
  D.19437 = mono_100ns_ticks ();
  gc_start_time.13 = gc_start_time;
  D.19439 = D.19437 - gc_start_time.13;
  D.19440 = D.19439 / 10;
  D.19441 = gc_stats.major_gc_time_usecs;
  D.19442 = D.19441 + D.19440;
  gc_stats.major_gc_time_usecs = D.19442;
  D.19443 = mono_100ns_ticks ();
  gc_start_time.13 = gc_start_time;
  D.19444 = D.19443 - gc_start_time.13;
  D.19445 = D.19444 / 10;
  mono_trace (32, 8, "gc took %d usecs", D.19445);
  goto <D.19098>;
  <D.19446>:
  <D.19098>:
  mono_profiler_gc_event (e, 0);
}


__attribute__((visibility ("hidden")))
mono_gc_register_root (char * start, size_t size, void * descr)
{
  sizetype D.19447;
  char * D.19448;
  int D.19449;

  D.19447 = size + 1;
  D.19448 = start + D.19447;
  GC_add_roots (start, D.19448);
  D.19449 = 1;
  return D.19449;
}


__attribute__((visibility ("hidden")))
mono_gc_deregister_root (char * addr)
{
  char * D.19451;

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


__attribute__((visibility ("hidden")))
mono_gc_weak_link_add (void * * link_addr, struct MonoObject * obj, gboolean track)
{
  long unsigned int obj.14;
  long unsigned int D.19453;
  void * D.19454;

  obj.14 = (long unsigned int) obj;
  D.19453 = ~obj.14;
  D.19454 = (void *) D.19453;
  *link_addr = D.19454;
  if (track != 0) goto <D.19455>; else goto <D.19456>;
  <D.19455>:
  GC_register_long_link (link_addr, obj);
  goto <D.19457>;
  <D.19456>:
  GC_general_register_disappearing_link (link_addr, obj);
  <D.19457>:
}


__attribute__((visibility ("hidden")))
mono_gc_weak_link_remove (void * * link_addr, gboolean track)
{
  if (track != 0) goto <D.19458>; else goto <D.19459>;
  <D.19458>:
  GC_unregister_long_link (link_addr);
  goto <D.19460>;
  <D.19459>:
  GC_unregister_disappearing_link (link_addr);
  <D.19460>:
  *link_addr = 0B;
}


__attribute__((visibility ("hidden")))
mono_gc_weak_link_get (void * * link_addr)
{
  struct MonoObject * D.19463;
  struct MonoObject * obj;

  obj = GC_call_with_alloc_lock (reveal_link, link_addr);
  if (obj == -1B) goto <D.19461>; else goto <D.19462>;
  <D.19461>:
  D.19463 = 0B;
  return D.19463;
  <D.19462>:
  D.19463 = obj;
  return D.19463;
}


reveal_link (void * link_addr)
{
  void * D.19465;
  void * D.19466;
  long unsigned int D.19467;
  long unsigned int D.19468;
  void * * link_a;

  link_a = link_addr;
  D.19466 = *link_a;
  D.19467 = (long unsigned int) D.19466;
  D.19468 = ~D.19467;
  D.19465 = (void *) D.19468;
  return D.19465;
}


__attribute__((visibility ("hidden")))
mono_gc_make_descr_for_string (gsize * bitmap, int numbits)
{
  void * D.19470;

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


__attribute__((visibility ("hidden")))
mono_gc_make_descr_for_object (gsize * bitmap, int numbits, size_t obj_size)
{
  void * D.19472;

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


__attribute__((visibility ("hidden")))
mono_gc_make_descr_for_array (int vector, gsize * elem_bitmap, int numbits, size_t elem_size)
{
  void * D.19474;

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


__attribute__((visibility ("hidden")))
mono_gc_make_descr_from_bitmap (gsize * bitmap, int numbits)
{
  void * D.19478;
  long unsigned int D.19479;
  long unsigned int D.19480;

  if (numbits > 29) goto <D.19476>; else goto <D.19477>;
  <D.19476>:
  D.19478 = 0B;
  return D.19478;
  <D.19477>:
  D.19479 = (long unsigned int) numbits;
  D.19480 = GC_make_descriptor (bitmap, D.19479);
  D.19478 = (void *) D.19480;
  return D.19478;
}


__attribute__((visibility ("hidden")))
mono_gc_make_root_descr_all_refs (int numbits)
{
  void * D.19482;

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


__attribute__((visibility ("hidden")))
mono_gc_alloc_fixed (size_t size, void * descr)
{
  void * D.19486;
  long unsigned int descr.15;

  if (descr != 0B) goto <D.19484>; else goto <D.19485>;
  <D.19484>:
  descr.15 = (long unsigned int) descr;
  D.19486 = GC_malloc_explicitly_typed (size, descr.15);
  return D.19486;
  <D.19485>:
  D.19486 = GC_local_malloc (size);
  return D.19486;
}


__attribute__((visibility ("hidden")))
mono_gc_free_fixed (void * addr)
{

}


mono_gc_invoke_finalizers ()
{
  int D.19489;
  int D.19492;

  D.19489 = GC_should_invoke_finalizers ();
  if (D.19489 != 0) goto <D.19490>; else goto <D.19491>;
  <D.19490>:
  D.19492 = GC_invoke_finalizers ();
  return D.19492;
  <D.19491>:
  D.19492 = 0;
  return D.19492;
}


__attribute__((visibility ("hidden")))
mono_gc_pending_finalizers ()
{
  gboolean D.19494;

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


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.19496;
  long unsigned int D.19497;

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


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.16;
  long unsigned int new_val.17;
  long unsigned int D.19500;
  void * D.19501;
  void * D.19502;
  void * old_val;

  <D.18139>:
  old_val = *val;
  old_val.16 = (long unsigned int) old_val;
  new_val.17 = (long unsigned int) new_val;
  D.19500 = __sync_val_compare_and_swap_8 (val, old_val.16, new_val.17);
  D.19501 = (void *) D.19500;
  if (D.19501 != old_val) goto <D.18139>; else goto <D.18140>;
  <D.18140>:
  D.19502 = old_val;
  return D.19502;
}


mono_gc_wbarrier_generic_nostore (void * ptr)
{

}


mono_gc_wbarrier_value_copy (void * dest, void * src, int count, struct MonoClass * klass)
{
  int D.19504;
  int D.19505;
  long unsigned int D.19506;

  D.19504 = mono_class_value_size (klass, 0B);
  D.19505 = D.19504 * count;
  D.19506 = (long unsigned int) D.19505;
  mono_gc_memmove_atomic (dest, src, D.19506);
}


mono_gc_wbarrier_object_copy (struct MonoObject * obj, struct MonoObject * src)
{
  void * D.19507;
  const void * D.19508;
  struct MonoVTable * D.19509;
  struct MonoClass * D.19510;
  int D.19511;
  long unsigned int D.19512;
  long unsigned int D.19513;

  D.19507 = obj + 16;
  D.19508 = src + 16;
  D.19509 = obj->vtable;
  D.19510 = D.19509->klass;
  D.19511 = D.19510->instance_size;
  D.19512 = (long unsigned int) D.19511;
  D.19513 = D.19512 + 18446744073709551600;
  mono_gc_memmove_aligned (D.19507, D.19508, D.19513);
}


__attribute__((visibility ("hidden")))
mono_gc_clear_domain (struct MonoDomain * domain)
{

}


__attribute__((visibility ("hidden")))
mono_gc_get_suspend_signal ()
{
  int D.19514;

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


__attribute__((visibility ("hidden")))
mono_gc_get_managed_allocator (struct MonoClass * klass, gboolean for_box)
{
  struct MonoMethod * D.19516;

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


__attribute__((visibility ("hidden")))
mono_gc_get_managed_array_allocator (struct MonoClass * klass)
{
  struct MonoMethod * D.19518;

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


__attribute__((visibility ("hidden")))
mono_gc_get_managed_allocator_by_type (int atype)
{
  struct MonoMethod * D.19520;

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


__attribute__((visibility ("hidden")))
mono_gc_get_managed_allocator_types ()
{
  guint32 D.19522;

  D.19522 = 0;
  return D.19522;
}


__attribute__((visibility ("hidden")))
mono_gc_get_write_barrier ()
{
  struct MonoMethod * D.19524;

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


__attribute__((visibility ("hidden")))
mono_gc_get_gc_name ()
{
  const char * D.19526;

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


__attribute__((visibility ("hidden")))
mono_gc_invoke_with_gc_lock (void * (*MonoGCLockedCallbackFunc) (void *) func, void * data)
{
  void * D.19528;

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


__attribute__((visibility ("hidden")))
mono_gc_get_description ()
{
  char * D.19530;

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


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

  if (str != 0B) goto <D.19532>; else goto <D.19533>;
  <D.19532>:
  D.19534 = __strdup (str);
  return D.19534;
  <D.19533>:
  D.19534 = 0B;
  return D.19534;
}


__attribute__((visibility ("hidden")))
mono_gc_set_desktop_mode ()
{
  GC_dont_expand = 1;
}


__attribute__((visibility ("hidden")))
mono_gc_is_moving ()
{
  gboolean D.19536;

  D.19536 = 0;
  return D.19536;
}


__attribute__((visibility ("hidden")))
mono_gc_is_disabled ()
{
  int GC_dont_gc.18;
  const gchar * D.19542;
  gboolean D.19543;

  GC_dont_gc.18 = GC_dont_gc;
  if (GC_dont_gc.18 != 0) goto <D.19538>; else goto <D.19541>;
  <D.19541>:
  D.19542 = monoeg_g_getenv ("GC_DONT_GC");
  if (D.19542 != 0B) goto <D.19538>; else goto <D.19539>;
  <D.19538>:
  D.19543 = 1;
  return D.19543;
  <D.19539>:
  D.19543 = 0;
  return D.19543;
}


__attribute__((visibility ("hidden")))
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);
}


__attribute__((visibility ("hidden")))
mono_gc_get_card_table (int * shift_bits, void * * card_mask)
{
  guint8 * D.19545;

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


__attribute__((visibility ("hidden")))
mono_gc_card_table_nursery_check ()
{
  gboolean D.19547;

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


__attribute__((visibility ("hidden")))
mono_gc_get_nursery (int * shift_bits, size_t * size)
{
  void * D.19549;

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


__attribute__((visibility ("hidden")))
mono_gc_set_current_thread_appdomain (struct MonoDomain * domain)
{

}


__attribute__((visibility ("hidden")))
mono_gc_precise_stack_mark_enabled ()
{
  gboolean D.19551;

  D.19551 = 0;
  return D.19551;
}


__attribute__((visibility ("hidden")))
mono_gc_get_logfile ()
{
  struct FILE * D.19553;

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


__attribute__((visibility ("hidden")))
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);
}


__attribute__((visibility ("hidden")))
mono_gc_scan_object (void * obj)
{
  void * D.19555;

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


__attribute__((visibility ("hidden")))
mono_gc_get_bitmap_for_descr (void * descr, int * numbits)
{
  gsize * D.19557;

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


__attribute__((visibility ("hidden")))
mono_gc_set_gc_callbacks (struct MonoGCCallbacks * callbacks)
{

}


__attribute__((visibility ("hidden")))
mono_gc_set_stack_end (void * stack_end)
{

}


__attribute__((visibility ("hidden")))
mono_gc_set_skip_thread (gboolean value)
{

}


__attribute__((visibility ("hidden")))
mono_gc_register_for_finalization (struct MonoObject * obj, void * user_data)
{
  void * D.19559;
  sizetype D.19560;
  sizetype D.19561;
  void * D.19562;
  _Bool D.19563;
  long int D.19564;
  long int D.19565;
  void * D.19568;
  void (*<T299a>) (void *, void *) user_data.19;
  long unsigned int D.19570;
  void * D.19571;
  guint offset;

  offset = 0;
  D.19559 = GC_base (obj);
  D.19560 = (sizetype) offset;
  D.19561 = -D.19560;
  D.19562 = obj + D.19561;
  D.19563 = D.19559 != D.19562;
  D.19564 = (long int) D.19563;
  D.19565 = __builtin_expect (D.19564, 0);
  if (D.19565 != 0) goto <D.19566>; else goto <D.19567>;
  <D.19566>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "boehm-gc.c", 1177, "GC_base (obj) == (char*)obj - offset");
  <D.19567>:
  D.19560 = (sizetype) offset;
  D.19561 = -D.19560;
  D.19568 = obj + D.19561;
  user_data.19 = (void (*<T299a>) (void *, void *)) user_data;
  D.19570 = (long unsigned int) offset;
  D.19571 = (void *) D.19570;
  GC_register_finalizer_no_order (D.19568, user_data.19, D.19571, 0B, 0B);
}


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

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


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

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


mono_gc_pthread_detach (pthread_t thread)
{
  int D.19576;

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


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


__attribute__((visibility ("hidden")))
mono_gc_get_vtable_bits (struct MonoClass * class)
{
  guint D.19578;

  D.19578 = 0;
  return D.19578;
}


__attribute__((visibility ("hidden")))
mono_gc_register_altstack (void * stack, gint32 stack_size, void * altstack, gint32 altstack_size)
{
  GC_register_altstack (stack, stack_size, altstack, altstack_size);
}


__attribute__((visibility ("hidden")))
mono_gc_get_los_limit ()
{
  int D.19580;

  D.19580 = 2147483647;
  return D.19580;
}


__attribute__((visibility ("hidden")))
mono_gc_user_markers_supported ()
{
  gboolean D.19582;

  D.19582 = 0;
  return D.19582;
}


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

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


__attribute__((visibility ("hidden")))
mono_gc_set_allow_synchronous_major (gboolean flag)
{
  gboolean D.19586;

  D.19586 = flag;
  return D.19586;
}