mono_gc_alloc_obj (struct MonoVTable * vtable, size_t size)
{
  int has_per_allocation_action.0;
  _Bool D.20006;
  long int D.20007;
  long int D.20008;
  unsigned int verify_before_allocs.1;
  unsigned int current_alloc.2;
  unsigned int D.20015;
  unsigned int collect_before_allocs.3;
  unsigned int D.20021;
  struct GCMemSection * nursery_section.4;
  struct SgenThreadInfo * sgen_thread_info.5;
  void * D.20030;
  _Bool D.20031;
  long int D.20032;
  long int D.20033;
  void * res;

  has_per_allocation_action.0 = has_per_allocation_action;
  D.20006 = has_per_allocation_action.0 != 0;
  D.20007 = (long int) D.20006;
  D.20008 = __builtin_expect (D.20007, 0);
  if (D.20008 != 0) goto <D.20009>; else goto <D.20010>;
  <D.20009>:
  {
    static int alloc_count;
    int current_alloc;

    current_alloc = InterlockedIncrement (&alloc_count);
    verify_before_allocs.1 = verify_before_allocs;
    if (verify_before_allocs.1 != 0) goto <D.20012>; else goto <D.20013>;
    <D.20012>:
    current_alloc.2 = (unsigned int) current_alloc;
    verify_before_allocs.1 = verify_before_allocs;
    D.20015 = current_alloc.2 % verify_before_allocs.1;
    if (D.20015 == 0) goto <D.20016>; else goto <D.20017>;
    <D.20016>:
    sgen_check_whole_heap_stw ();
    <D.20017>:
    <D.20013>:
    collect_before_allocs.3 = collect_before_allocs;
    if (collect_before_allocs.3 != 0) goto <D.20019>; else goto <D.20020>;
    <D.20019>:
    current_alloc.2 = (unsigned int) current_alloc;
    collect_before_allocs.3 = collect_before_allocs;
    D.20021 = current_alloc.2 % collect_before_allocs.3;
    if (D.20021 == 0) goto <D.20022>; else goto <D.20023>;
    <D.20022>:
    nursery_section.4 = nursery_section;
    if (nursery_section.4 != 0B) goto <D.20025>; else goto <D.20026>;
    <D.20025>:
    pthread_mutex_lock (&gc_mutex);
    sgen_perform_collection (0, 0, "collect-before-alloc-triggered", 1);
    sgen_gc_unlock ();
    <D.20026>:
    <D.20023>:
    <D.20020>:
  }
  <D.20010>:
  sgen_thread_info.5 = sgen_thread_info;
  sgen_thread_info.5->in_critical_region = 1;
  mono_memory_barrier ();
  res = mono_gc_try_alloc_obj_nolock (vtable, size);
  if (res != 0B) goto <D.20028>; else goto <D.20029>;
  <D.20028>:
  mono_memory_barrier ();
  sgen_thread_info.5 = sgen_thread_info;
  sgen_thread_info.5->in_critical_region = 0;
  D.20030 = res;
  return D.20030;
  <D.20029>:
  mono_memory_barrier ();
  sgen_thread_info.5 = sgen_thread_info;
  sgen_thread_info.5->in_critical_region = 0;
  pthread_mutex_lock (&gc_mutex);
  res = mono_gc_alloc_obj_nolock (vtable, size);
  sgen_gc_unlock ();
  D.20031 = res == 0B;
  D.20032 = (long int) D.20031;
  D.20033 = __builtin_expect (D.20032, 0);
  if (D.20033 != 0) goto <D.20034>; else goto <D.20035>;
  <D.20034>:
  D.20030 = mono_gc_out_of_memory (size);
  return D.20030;
  <D.20035>:
  D.20030 = res;
  return D.20030;
}


InterlockedIncrement (volatile gint32 * val)
{
  gint32 D.20037;
  unsigned int D.20038;

  D.20038 = __sync_add_and_fetch_4 (val, 1);
  D.20037 = (gint32) D.20038;
  return D.20037;
}


mono_gc_try_alloc_obj_nolock (struct MonoVTable * vtable, size_t size)
{
  long unsigned int D.20040;
  void * D.20043;
  _Bool D.20044;
  long int D.20045;
  long int D.20046;
  void * D.20051;
  unsigned int tlab_size.6;
  long unsigned int D.20053;
  _Bool D.20054;
  long int D.20055;
  long int D.20056;
  <unnamed type> nursery_clear_policy.7;
  long int real_end.8;
  long int p.9;
  long int D.20067;
  _Bool D.20068;
  long int D.20069;
  long int D.20070;
  char * tlab_temp_end.10;
  _Bool D.20074;
  long int D.20075;
  long int D.20076;
  char * tlab_next.11;
  char * D.20080;
  char * tlab_real_end.12;
  char * tlab_temp_end.13;
  struct FILE * gc_debug_file.14;
  long int D.20094;
  char * tlab_next.15;
  long unsigned int alloc_size.16;
  char * tlab_real_end.17;
  long unsigned int D.20100;
  char * tlab_temp_end.18;
  struct MonoClass * D.20106;
  const char * D.20107;
  void * D.20110;
  _Bool D.20111;
  long int D.20112;
  long int D.20113;
  void * * p;
  char * new_next;

  D.20040 = size + 7;
  size = D.20040 & 18446744073709551608;
  if (0 != 0) goto <D.20041>; else goto <D.20042>;
  <D.20041>:
  monoeg_g_log (0B, 4, "Object too small");
  <D.19880>:
  goto <D.19880>;
  <D.20042>:
  D.20043 = vtable->gc_descr;
  D.20044 = D.20043 == 0B;
  D.20045 = (long int) D.20044;
  D.20046 = __builtin_expect (D.20045, 0);
  if (D.20046 != 0) goto <D.20047>; else goto <D.20048>;
  <D.20047>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "sgen-alloc.c", 352, "vtable->gc_descr");
  <D.20048>:
  if (size > 8000) goto <D.20049>; else goto <D.20050>;
  <D.20049>:
  D.20051 = 0B;
  return D.20051;
  <D.20050>:
  tlab_size.6 = tlab_size;
  D.20053 = (long unsigned int) tlab_size.6;
  D.20054 = D.20053 < size;
  D.20055 = (long int) D.20054;
  D.20056 = __builtin_expect (D.20055, 0);
  if (D.20056 != 0) goto <D.20057>; else goto <D.20058>;
  <D.20057>:
  p = sgen_nursery_alloc (size);
  if (p == 0B) goto <D.20059>; else goto <D.20060>;
  <D.20059>:
  D.20051 = 0B;
  return D.20051;
  <D.20060>:
  sgen_set_nursery_scan_start (p);
  nursery_clear_policy.7 = nursery_clear_policy;
  if (nursery_clear_policy.7 == 1) goto <D.20062>; else goto <D.20063>;
  <D.20062>:
  memset (p, 0, size);
  <D.20063>:
  goto <D.20064>;
  <D.20058>:
  {
    int available_in_tlab;
    char * real_end;

    p = tlab_next;
    new_next = p + size;
    real_end = tlab_real_end;
    real_end.8 = (long int) real_end;
    p.9 = (long int) p;
    D.20067 = real_end.8 - p.9;
    available_in_tlab = (int) D.20067;
    D.20068 = new_next < real_end;
    D.20069 = (long int) D.20068;
    D.20070 = __builtin_expect (D.20069, 1);
    if (D.20070 != 0) goto <D.20071>; else goto <D.20072>;
    <D.20071>:
    tlab_next = new_next;
    tlab_temp_end.10 = tlab_temp_end;
    D.20074 = new_next >= tlab_temp_end.10;
    D.20075 = (long int) D.20074;
    D.20076 = __builtin_expect (D.20075, 0);
    if (D.20076 != 0) goto <D.20077>; else goto <D.20078>;
    <D.20077>:
    sgen_set_nursery_scan_start (new_next);
    tlab_next.11 = tlab_next;
    D.20080 = tlab_next.11 + 8192;
    tlab_real_end.12 = tlab_real_end;
    tlab_temp_end.13 = MIN_EXPR <D.20080, tlab_real_end.12>;
    tlab_temp_end = tlab_temp_end.13;
    if (0 != 0) goto <D.20083>; else goto <D.20084>;
    <D.20083>:
    gc_debug_file.14 = gc_debug_file;
    tlab_next.11 = tlab_next;
    tlab_temp_end.10 = tlab_temp_end;
    fprintf (gc_debug_file.14, "Expanding local alloc: %p-%p\n", tlab_next.11, tlab_temp_end.10);
    gc_debug_file.14 = gc_debug_file;
    fflush (gc_debug_file.14);
    <D.20084>:
    <D.20078>:
    goto <D.20086>;
    <D.20072>:
    if (available_in_tlab > 512) goto <D.20087>; else goto <D.20088>;
    <D.20087>:
    p = sgen_nursery_alloc (size);
    if (p == 0B) goto <D.20089>; else goto <D.20090>;
    <D.20089>:
    D.20051 = 0B;
    return D.20051;
    <D.20090>:
    nursery_clear_policy.7 = nursery_clear_policy;
    if (nursery_clear_policy.7 == 1) goto <D.20091>; else goto <D.20092>;
    <D.20091>:
    memset (p, 0, size);
    <D.20092>:
    goto <D.20093>;
    <D.20088>:
    {
      size_t alloc_size;

      try
        {
          alloc_size = 0;
          D.20094 = (long int) available_in_tlab;
          sgen_nursery_retire_region (p, D.20094);
          tlab_size.6 = tlab_size;
          D.20053 = (long unsigned int) tlab_size.6;
          new_next = sgen_nursery_alloc_range (D.20053, size, &alloc_size);
          p = new_next;
          if (p == 0B) goto <D.20095>; else goto <D.20096>;
          <D.20095>:
          D.20051 = 0B;
          return D.20051;
          <D.20096>:
          tlab_start = new_next;
          tlab_next.15 = new_next + size;
          tlab_next = tlab_next.15;
          alloc_size.16 = alloc_size;
          tlab_real_end.17 = new_next + alloc_size.16;
          tlab_real_end = tlab_real_end.17;
          alloc_size.16 = alloc_size;
          D.20100 = MIN_EXPR <alloc_size.16, 8192>;
          tlab_temp_end.18 = new_next + D.20100;
          tlab_temp_end = tlab_temp_end.18;
          sgen_set_nursery_scan_start (p);
          nursery_clear_policy.7 = nursery_clear_policy;
          if (nursery_clear_policy.7 == 1) goto <D.20102>; else goto <D.20103>;
          <D.20102>:
          alloc_size.16 = alloc_size;
          memset (new_next, 0, alloc_size.16);
          <D.20103>:
        }
      finally
        {
          alloc_size = {CLOBBER};
        }
    }
    <D.20093>:
    <D.20086>:
  }
  <D.20064>:
  if (0 != 0) goto <D.20104>; else goto <D.20105>;
  <D.20104>:
  gc_debug_file.14 = gc_debug_file;
  D.20106 = vtable->klass;
  D.20107 = D.20106->name;
  fprintf (gc_debug_file.14, "Allocated object %p, vtable: %p (%s), size: %zd\n", p, vtable, D.20107, size);
  gc_debug_file.14 = gc_debug_file;
  fflush (gc_debug_file.14);
  <D.20105>:
  if (0 != 0) goto <D.20108>; else goto <D.20109>;
  <D.20108>:
  <D.20109>:
  D.20110 = *p;
  D.20111 = D.20110 != 0B;
  D.20112 = (long int) D.20111;
  D.20113 = __builtin_expect (D.20112, 0);
  if (D.20113 != 0) goto <D.20114>; else goto <D.20115>;
  <D.20114>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "sgen-alloc.c", 425, "*p == NULL");
  <D.20115>:
  mono_memory_write_barrier ();
  *p = vtable;
  D.20051 = p;
  return D.20051;
}


sgen_set_nursery_scan_start (char * p)
{
  long int p.19;
  struct GCMemSection * nursery_section.20;
  char * D.20121;
  long int D.20122;
  long int D.20123;
  long int D.20124;
  char * * D.20125;
  long unsigned int D.20126;
  long unsigned int D.20127;
  char * * D.20128;
  int idx;
  char * old;

  p.19 = (long int) p;
  nursery_section.20 = nursery_section;
  D.20121 = nursery_section.20->data;
  D.20122 = (long int) D.20121;
  D.20123 = p.19 - D.20122;
  D.20124 = D.20123 / 8192;
  idx = (int) D.20124;
  nursery_section.20 = nursery_section;
  D.20125 = nursery_section.20->scan_starts;
  D.20126 = (long unsigned int) idx;
  D.20127 = D.20126 * 8;
  D.20128 = D.20125 + D.20127;
  old = *D.20128;
  if (old == 0B) goto <D.20129>; else goto <D.20131>;
  <D.20131>:
  if (old > p) goto <D.20129>; else goto <D.20130>;
  <D.20129>:
  nursery_section.20 = nursery_section;
  D.20125 = nursery_section.20->scan_starts;
  D.20126 = (long unsigned int) idx;
  D.20127 = D.20126 * 8;
  D.20128 = D.20125 + D.20127;
  *D.20128 = p;
  <D.20130>:
}


memset (void * __dest, int __ch, size_t __len)
{
  int D.20134;
  int D.20139;
  void * D.20141;
  long unsigned int D.20142;

  D.20134 = __builtin_constant_p (__len);
  if (D.20134 != 0) goto <D.20135>; else goto <D.20136>;
  <D.20135>:
  if (__len == 0) goto <D.20137>; else goto <D.20138>;
  <D.20137>:
  D.20139 = __builtin_constant_p (__ch);
  if (D.20139 == 0) goto <D.20132>; else goto <D.20140>;
  <D.20140>:
  if (__ch != 0) goto <D.20132>; else goto <D.20133>;
  <D.20132>:
  __warn_memset_zero_len ();
  D.20141 = __dest;
  return D.20141;
  <D.20133>:
  <D.20138>:
  <D.20136>:
  D.20142 = __builtin_object_size (__dest, 0);
  D.20141 = __builtin___memset_chk (__dest, __ch, __len, D.20142);
  return D.20141;
}


mono_memory_write_barrier ()
{
  mono_memory_barrier ();
}


mono_memory_barrier ()
{
  __sync_synchronize ();
}


mono_gc_alloc_obj_nolock (struct MonoVTable * vtable, size_t size)
{
  long unsigned int D.20147;
  void * D.20148;
  _Bool D.20149;
  long int D.20150;
  long int D.20151;
  int has_per_allocation_action.21;
  _Bool D.20155;
  long int D.20156;
  long int D.20157;
  unsigned int collect_before_allocs.22;
  unsigned int current_alloc.23;
  unsigned int D.20164;
  struct GCMemSection * nursery_section.24;
  int degraded_mode.25;
  int D.20173;
  unsigned int verify_before_allocs.26;
  unsigned int D.20182;
  char * tlab_temp_end.27;
  _Bool D.20189;
  long int D.20190;
  long int D.20191;
  struct FILE * gc_debug_file.28;
  struct MonoClass * D.20197;
  const char * D.20198;
  void * D.20201;
  _Bool D.20202;
  long int D.20203;
  long int D.20204;
  void * D.20207;
  char * tlab_next.29;
  char * tlab_real_end.30;
  sizetype D.20212;
  char * tlab_next.31;
  int sgen_nursery_size.32;
  long int tlab_real_end.33;
  long int tlab_next.34;
  long int D.20221;
  unsigned int tlab_size.35;
  long unsigned int D.20226;
  <unnamed type> nursery_clear_policy.36;
  char * tlab_start.37;
  long unsigned int D.20244;
  long unsigned int D.20245;
  long int D.20246;
  long int D.20247;
  long unsigned int alloc_size.38;
  char * tlab_real_end.39;
  long unsigned int D.20258;
  char * tlab_temp_end.40;
  char * tlab_next.41;
  char * D.20264;
  char * tlab_temp_end.42;
  _Bool D.20268;
  long int D.20269;
  long int D.20270;
  void * * p;
  char * new_next;

  if (size <= 8000) goto <D.20144>; else goto <D.20145>;
  <D.20144>:
  goto <D.20146>;
  <D.20145>:
  <D.20146>:
  D.20147 = size + 7;
  size = D.20147 & 18446744073709551608;
  D.20148 = vtable->gc_descr;
  D.20149 = D.20148 == 0B;
  D.20150 = (long int) D.20149;
  D.20151 = __builtin_expect (D.20150, 0);
  if (D.20151 != 0) goto <D.20152>; else goto <D.20153>;
  <D.20152>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "sgen-alloc.c", 172, "vtable->gc_descr");
  <D.20153>:
  has_per_allocation_action.21 = has_per_allocation_action;
  D.20155 = has_per_allocation_action.21 != 0;
  D.20156 = (long int) D.20155;
  D.20157 = __builtin_expect (D.20156, 0);
  if (D.20157 != 0) goto <D.20158>; else goto <D.20159>;
  <D.20158>:
  {
    static int alloc_count;
    int current_alloc;

    current_alloc = InterlockedIncrement (&alloc_count);
    collect_before_allocs.22 = collect_before_allocs;
    if (collect_before_allocs.22 != 0) goto <D.20161>; else goto <D.20162>;
    <D.20161>:
    current_alloc.23 = (unsigned int) current_alloc;
    collect_before_allocs.22 = collect_before_allocs;
    D.20164 = current_alloc.23 % collect_before_allocs.22;
    if (D.20164 == 0) goto <D.20165>; else goto <D.20166>;
    <D.20165>:
    nursery_section.24 = nursery_section;
    if (nursery_section.24 != 0B) goto <D.20168>; else goto <D.20169>;
    <D.20168>:
    sgen_perform_collection (0, 0, "collect-before-alloc-triggered", 1);
    degraded_mode.25 = degraded_mode;
    if (degraded_mode.25 == 0) goto <D.20171>; else goto <D.20172>;
    <D.20171>:
    D.20173 = sgen_can_alloc_size (size);
    if (D.20173 != 0) goto <D.20174>; else goto <D.20175>;
    <D.20174>:
    if (size <= 8000) goto <D.20176>; else goto <D.20177>;
    <D.20176>:
    monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "sgen-alloc.c", 183);
    <D.20177>:
    <D.20175>:
    <D.20172>:
    <D.20169>:
    <D.20166>:
    goto <D.20178>;
    <D.20162>:
    verify_before_allocs.26 = verify_before_allocs;
    if (verify_before_allocs.26 != 0) goto <D.20180>; else goto <D.20181>;
    <D.20180>:
    current_alloc.23 = (unsigned int) current_alloc;
    verify_before_allocs.26 = verify_before_allocs;
    D.20182 = current_alloc.23 % verify_before_allocs.26;
    if (D.20182 == 0) goto <D.20183>; else goto <D.20184>;
    <D.20183>:
    sgen_check_whole_heap_stw ();
    <D.20184>:
    <D.20181>:
    <D.20178>:
  }
  <D.20159>:
  if (size > 8000) goto <D.20185>; else goto <D.20186>;
  <D.20185>:
  p = sgen_los_alloc_large_inner (vtable, size);
  goto <D.20187>;
  <D.20186>:
  p = tlab_next;
  new_next = p + size;
  tlab_next = new_next;
  tlab_temp_end.27 = tlab_temp_end;
  D.20189 = new_next < tlab_temp_end.27;
  D.20190 = (long int) D.20189;
  D.20191 = __builtin_expect (D.20190, 1);
  if (D.20191 != 0) goto <D.20192>; else goto <D.20193>;
  <D.20192>:
  if (0 != 0) goto <D.20194>; else goto <D.20195>;
  <D.20194>:
  gc_debug_file.28 = gc_debug_file;
  D.20197 = vtable->klass;
  D.20198 = D.20197->name;
  fprintf (gc_debug_file.28, "Allocated object %p, vtable: %p (%s), size: %zd\n", p, vtable, D.20198, size);
  gc_debug_file.28 = gc_debug_file;
  fflush (gc_debug_file.28);
  <D.20195>:
  if (0 != 0) goto <D.20199>; else goto <D.20200>;
  <D.20199>:
  <D.20200>:
  D.20201 = *p;
  D.20202 = D.20201 != 0B;
  D.20203 = (long int) D.20202;
  D.20204 = __builtin_expect (D.20203, 0);
  if (D.20204 != 0) goto <D.20205>; else goto <D.20206>;
  <D.20205>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "sgen-alloc.c", 225, "*p == NULL");
  <D.20206>:
  mono_memory_write_barrier ();
  *p = vtable;
  D.20207 = p;
  return D.20207;
  <D.20193>:
  tlab_next.29 = tlab_next;
  tlab_real_end.30 = tlab_real_end;
  if (tlab_next.29 >= tlab_real_end.30) goto <D.20210>; else goto <D.20211>;
  <D.20210>:
  {
    int available_in_tlab;

    tlab_next.29 = tlab_next;
    D.20212 = -size;
    tlab_next.31 = tlab_next.29 + D.20212;
    tlab_next = tlab_next.31;
    degraded_mode.25 = degraded_mode;
    if (degraded_mode.25 != 0) goto <D.20214>; else goto <D.20215>;
    <D.20214>:
    degraded_mode.25 = degraded_mode;
    sgen_nursery_size.32 = sgen_nursery_size;
    if (degraded_mode.25 < sgen_nursery_size.32) goto <D.20217>; else goto <D.20218>;
    <D.20217>:
    D.20207 = alloc_degraded (vtable, size, 0);
    return D.20207;
    <D.20218>:
    <D.20215>:
    tlab_real_end.30 = tlab_real_end;
    tlab_real_end.33 = (long int) tlab_real_end.30;
    tlab_next.29 = tlab_next;
    tlab_next.34 = (long int) tlab_next.29;
    D.20221 = tlab_real_end.33 - tlab_next.34;
    available_in_tlab = (int) D.20221;
    tlab_size.35 = tlab_size;
    D.20226 = (long unsigned int) tlab_size.35;
    if (D.20226 < size) goto <D.20222>; else goto <D.20227>;
    <D.20227>:
    if (available_in_tlab > 512) goto <D.20222>; else goto <D.20223>;
    <D.20222>:
    <D.19869>:
    p = sgen_nursery_alloc (size);
    if (p == 0B) goto <D.20228>; else goto <D.20229>;
    <D.20228>:
    sgen_ensure_free_space (size);
    degraded_mode.25 = degraded_mode;
    if (degraded_mode.25 != 0) goto <D.20230>; else goto <D.20231>;
    <D.20230>:
    D.20207 = alloc_degraded (vtable, size, 0);
    return D.20207;
    <D.20231>:
    p = sgen_nursery_alloc (size);
    <D.20229>:
    if (p == 0B) goto <D.19869>; else goto <D.19870>;
    <D.19870>:
    if (p == 0B) goto <D.20232>; else goto <D.20233>;
    <D.20232>:
    if (1 != 0) goto <D.20234>; else goto <D.20235>;
    <D.20234>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "sgen-alloc.c", 273, "0");
    <D.20235>:
    <D.20233>:
    nursery_clear_policy.36 = nursery_clear_policy;
    if (nursery_clear_policy.36 == 1) goto <D.20237>; else goto <D.20238>;
    <D.20237>:
    memset (p, 0, size);
    <D.20238>:
    goto <D.20224>;
    <D.20223>:
    {
      size_t alloc_size;

      try
        {
          alloc_size = 0;
          tlab_start.37 = tlab_start;
          if (tlab_start.37 != 0B) goto <D.20240>; else goto <D.20241>;
          <D.20240>:
          if (0 != 0) goto <D.20242>; else goto <D.20243>;
          <D.20242>:
          gc_debug_file.28 = gc_debug_file;
          tlab_start.37 = tlab_start;
          tlab_real_end.30 = tlab_real_end;
          tlab_real_end.30 = tlab_real_end;
          tlab_real_end.33 = (long int) tlab_real_end.30;
          tlab_next.29 = tlab_next;
          tlab_next.34 = (long int) tlab_next.29;
          D.20221 = tlab_real_end.33 - tlab_next.34;
          D.20244 = (long unsigned int) D.20221;
          D.20245 = D.20244 - size;
          D.20246 = (long int) D.20245;
          fprintf (gc_debug_file.28, "Retire TLAB: %p-%p [%ld]\n", tlab_start.37, tlab_real_end.30, D.20246);
          gc_debug_file.28 = gc_debug_file;
          fflush (gc_debug_file.28);
          <D.20243>:
          <D.20241>:
          D.20247 = (long int) available_in_tlab;
          sgen_nursery_retire_region (p, D.20247);
          <D.19872>:
          tlab_size.35 = tlab_size;
          D.20226 = (long unsigned int) tlab_size.35;
          p = sgen_nursery_alloc_range (D.20226, size, &alloc_size);
          if (p == 0B) goto <D.20248>; else goto <D.20249>;
          <D.20248>:
          tlab_size.35 = tlab_size;
          D.20226 = (long unsigned int) tlab_size.35;
          sgen_ensure_free_space (D.20226);
          degraded_mode.25 = degraded_mode;
          if (degraded_mode.25 != 0) goto <D.20250>; else goto <D.20251>;
          <D.20250>:
          D.20207 = alloc_degraded (vtable, size, 0);
          return D.20207;
          <D.20251>:
          tlab_size.35 = tlab_size;
          D.20226 = (long unsigned int) tlab_size.35;
          p = sgen_nursery_alloc_range (D.20226, size, &alloc_size);
          <D.20249>:
          if (p == 0B) goto <D.19872>; else goto <D.19873>;
          <D.19873>:
          if (p == 0B) goto <D.20252>; else goto <D.20253>;
          <D.20252>:
          if (1 != 0) goto <D.20254>; else goto <D.20255>;
          <D.20254>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "sgen-alloc.c", 298, "0");
          <D.20255>:
          <D.20253>:
          tlab_start = p;
          tlab_start.37 = tlab_start;
          tlab_next = tlab_start.37;
          tlab_start.37 = tlab_start;
          alloc_size.38 = alloc_size;
          tlab_real_end.39 = tlab_start.37 + alloc_size.38;
          tlab_real_end = tlab_real_end.39;
          tlab_start.37 = tlab_start;
          alloc_size.38 = alloc_size;
          D.20258 = MIN_EXPR <alloc_size.38, 8192>;
          tlab_temp_end.40 = tlab_start.37 + D.20258;
          tlab_temp_end = tlab_temp_end.40;
          nursery_clear_policy.36 = nursery_clear_policy;
          if (nursery_clear_policy.36 == 1) goto <D.20260>; else goto <D.20261>;
          <D.20260>:
          tlab_start.37 = tlab_start;
          alloc_size.38 = alloc_size;
          memset (tlab_start.37, 0, alloc_size.38);
          <D.20261>:
          p = tlab_next;
          tlab_next.29 = tlab_next;
          tlab_next.41 = tlab_next.29 + size;
          tlab_next = tlab_next.41;
          sgen_set_nursery_scan_start (p);
        }
      finally
        {
          alloc_size = {CLOBBER};
        }
    }
    <D.20224>:
  }
  goto <D.20263>;
  <D.20211>:
  sgen_set_nursery_scan_start (p);
  tlab_next.29 = tlab_next;
  D.20264 = tlab_next.29 + 8192;
  tlab_real_end.30 = tlab_real_end;
  tlab_temp_end.42 = MIN_EXPR <D.20264, tlab_real_end.30>;
  tlab_temp_end = tlab_temp_end.42;
  if (0 != 0) goto <D.20266>; else goto <D.20267>;
  <D.20266>:
  gc_debug_file.28 = gc_debug_file;
  tlab_next.29 = tlab_next;
  tlab_temp_end.27 = tlab_temp_end;
  fprintf (gc_debug_file.28, "Expanding local alloc: %p-%p\n", tlab_next.29, tlab_temp_end.27);
  gc_debug_file.28 = gc_debug_file;
  fflush (gc_debug_file.28);
  <D.20267>:
  <D.20263>:
  <D.20187>:
  D.20268 = p != 0B;
  D.20269 = (long int) D.20268;
  D.20270 = __builtin_expect (D.20269, 1);
  if (D.20270 != 0) goto <D.20271>; else goto <D.20272>;
  <D.20271>:
  if (0 != 0) goto <D.20273>; else goto <D.20274>;
  <D.20273>:
  gc_debug_file.28 = gc_debug_file;
  D.20197 = vtable->klass;
  D.20198 = D.20197->name;
  fprintf (gc_debug_file.28, "Allocated object %p, vtable: %p (%s), size: %zd\n", p, vtable, D.20198, size);
  gc_debug_file.28 = gc_debug_file;
  fflush (gc_debug_file.28);
  <D.20274>:
  if (0 != 0) goto <D.20275>; else goto <D.20276>;
  <D.20275>:
  if (size > 8000) goto <D.20277>; else goto <D.20278>;
  <D.20277>:
  goto <D.20279>;
  <D.20278>:
  <D.20279>:
  <D.20276>:
  mono_memory_write_barrier ();
  *p = vtable;
  <D.20272>:
  D.20207 = p;
  return D.20207;
}


alloc_degraded (struct MonoVTable * vtable, size_t size, gboolean for_mature)
{
  int last_major_gc_warned.43;
  int stat_major_gcs.44;
  int num_degraded.45;
  int num_degraded.46;
  struct _IO_FILE * stderr.47;
  int D.20298;
  int D.20300;
  _Bool D.20303;
  int D.20304;
  void * (*<T2d6d>) (struct MonoVTable *, size_t) D.20305;
  void * D.20309;
  static int last_major_gc_warned = -1;
  static int num_degraded = 0;
  void * p;

  if (for_mature == 0) goto <D.20283>; else goto <D.20284>;
  <D.20283>:
  last_major_gc_warned.43 = last_major_gc_warned;
  stat_major_gcs.44 = stat_major_gcs;
  if (last_major_gc_warned.43 < stat_major_gcs.44) goto <D.20287>; else goto <D.20288>;
  <D.20287>:
  num_degraded.45 = num_degraded;
  num_degraded.46 = num_degraded.45 + 1;
  num_degraded = num_degraded.46;
  num_degraded.45 = num_degraded;
  if (num_degraded.45 == 1) goto <D.20291>; else goto <D.20294>;
  <D.20294>:
  num_degraded.45 = num_degraded;
  if (num_degraded.45 == 3) goto <D.20291>; else goto <D.20292>;
  <D.20291>:
  stderr.47 = stderr;
  fprintf (stderr.47, "Warning: Degraded allocation.  Consider increasing nursery-size if the warning persists.\n");
  goto <D.20293>;
  <D.20292>:
  num_degraded.45 = num_degraded;
  if (num_degraded.45 == 10) goto <D.20296>; else goto <D.20297>;
  <D.20296>:
  stderr.47 = stderr;
  fprintf (stderr.47, "Warning: Repeated degraded allocation.  Consider increasing nursery-size.\n");
  <D.20297>:
  <D.20293>:
  stat_major_gcs.44 = stat_major_gcs;
  last_major_gc_warned = stat_major_gcs.44;
  <D.20288>:
  D.20298 = (int) size;
  InterlockedExchangeAdd (&degraded_mode, D.20298);
  sgen_ensure_free_space (size);
  goto <D.20299>;
  <D.20284>:
  D.20300 = sgen_need_major_collection (size);
  if (D.20300 != 0) goto <D.20301>; else goto <D.20302>;
  <D.20301>:
  D.20303 = for_mature == 0;
  D.20304 = (int) D.20303;
  sgen_perform_collection (size, 1, "mature allocation failure", D.20304);
  <D.20302>:
  <D.20299>:
  D.20305 = major_collector.alloc_degraded;
  p = D.20305 (vtable, size);
  if (for_mature != 0) goto <D.20306>; else goto <D.20307>;
  <D.20306>:
  goto <D.20308>;
  <D.20307>:
  <D.20308>:
  D.20309 = p;
  return D.20309;
}


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

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


InterlockedExchangeAdd (volatile gint32 * val, gint32 add)
{
  gint32 D.20313;
  unsigned int add.48;
  unsigned int D.20315;

  add.48 = (unsigned int) add;
  D.20315 = __sync_fetch_and_add_4 (val, add.48);
  D.20313 = (gint32) D.20315;
  return D.20313;
}


mono_gc_alloc_vector (struct MonoVTable * vtable, size_t size, uintptr_t max_length)
{
  struct SgenThreadInfo * sgen_thread_info.49;
  unsigned int D.20320;
  void * D.20321;
  _Bool D.20322;
  long int D.20323;
  long int D.20324;
  struct MonoArray * arr;

  sgen_thread_info.49 = sgen_thread_info;
  sgen_thread_info.49->in_critical_region = 1;
  mono_memory_barrier ();
  arr = mono_gc_try_alloc_obj_nolock (vtable, size);
  if (arr != 0B) goto <D.20318>; else goto <D.20319>;
  <D.20318>:
  D.20320 = (unsigned int) max_length;
  arr->max_length = D.20320;
  mono_memory_barrier ();
  sgen_thread_info.49 = sgen_thread_info;
  sgen_thread_info.49->in_critical_region = 0;
  D.20321 = arr;
  return D.20321;
  <D.20319>:
  mono_memory_barrier ();
  sgen_thread_info.49 = sgen_thread_info;
  sgen_thread_info.49->in_critical_region = 0;
  pthread_mutex_lock (&gc_mutex);
  arr = mono_gc_alloc_obj_nolock (vtable, size);
  D.20322 = arr == 0B;
  D.20323 = (long int) D.20322;
  D.20324 = __builtin_expect (D.20323, 0);
  if (D.20324 != 0) goto <D.20325>; else goto <D.20326>;
  <D.20325>:
  sgen_gc_unlock ();
  D.20321 = mono_gc_out_of_memory (size);
  return D.20321;
  <D.20326>:
  D.20320 = (unsigned int) max_length;
  arr->max_length = D.20320;
  sgen_gc_unlock ();
  D.20321 = arr;
  return D.20321;
}


mono_gc_alloc_array (struct MonoVTable * vtable, size_t size, uintptr_t max_length, uintptr_t bounds_size)
{
  struct SgenThreadInfo * sgen_thread_info.50;
  unsigned int D.20331;
  sizetype D.20332;
  void * D.20333;
  _Bool D.20334;
  long int D.20335;
  long int D.20336;
  struct MonoArray * arr;
  struct MonoArrayBounds * bounds;

  sgen_thread_info.50 = sgen_thread_info;
  sgen_thread_info.50->in_critical_region = 1;
  mono_memory_barrier ();
  arr = mono_gc_try_alloc_obj_nolock (vtable, size);
  if (arr != 0B) goto <D.20329>; else goto <D.20330>;
  <D.20329>:
  D.20331 = (unsigned int) max_length;
  arr->max_length = D.20331;
  D.20332 = size - bounds_size;
  bounds = arr + D.20332;
  arr->bounds = bounds;
  mono_memory_barrier ();
  sgen_thread_info.50 = sgen_thread_info;
  sgen_thread_info.50->in_critical_region = 0;
  D.20333 = arr;
  return D.20333;
  <D.20330>:
  mono_memory_barrier ();
  sgen_thread_info.50 = sgen_thread_info;
  sgen_thread_info.50->in_critical_region = 0;
  pthread_mutex_lock (&gc_mutex);
  arr = mono_gc_alloc_obj_nolock (vtable, size);
  D.20334 = arr == 0B;
  D.20335 = (long int) D.20334;
  D.20336 = __builtin_expect (D.20335, 0);
  if (D.20336 != 0) goto <D.20337>; else goto <D.20338>;
  <D.20337>:
  sgen_gc_unlock ();
  D.20333 = mono_gc_out_of_memory (size);
  return D.20333;
  <D.20338>:
  D.20331 = (unsigned int) max_length;
  arr->max_length = D.20331;
  D.20332 = size - bounds_size;
  bounds = arr + D.20332;
  arr->bounds = bounds;
  sgen_gc_unlock ();
  D.20333 = arr;
  return D.20333;
}


mono_gc_alloc_string (struct MonoVTable * vtable, size_t size, gint32 len)
{
  struct SgenThreadInfo * sgen_thread_info.51;
  void * D.20343;
  _Bool D.20344;
  long int D.20345;
  long int D.20346;
  struct MonoString * str;

  sgen_thread_info.51 = sgen_thread_info;
  sgen_thread_info.51->in_critical_region = 1;
  mono_memory_barrier ();
  str = mono_gc_try_alloc_obj_nolock (vtable, size);
  if (str != 0B) goto <D.20341>; else goto <D.20342>;
  <D.20341>:
  str->length = len;
  mono_memory_barrier ();
  sgen_thread_info.51 = sgen_thread_info;
  sgen_thread_info.51->in_critical_region = 0;
  D.20343 = str;
  return D.20343;
  <D.20342>:
  mono_memory_barrier ();
  sgen_thread_info.51 = sgen_thread_info;
  sgen_thread_info.51->in_critical_region = 0;
  pthread_mutex_lock (&gc_mutex);
  str = mono_gc_alloc_obj_nolock (vtable, size);
  D.20344 = str == 0B;
  D.20345 = (long int) D.20344;
  D.20346 = __builtin_expect (D.20345, 0);
  if (D.20346 != 0) goto <D.20347>; else goto <D.20348>;
  <D.20347>:
  sgen_gc_unlock ();
  D.20343 = mono_gc_out_of_memory (size);
  return D.20343;
  <D.20348>:
  str->length = len;
  sgen_gc_unlock ();
  D.20343 = str;
  return D.20343;
}


mono_gc_alloc_pinned_obj (struct MonoVTable * vtable, size_t size)
{
  long unsigned int D.20350;
  struct MonoClass * D.20356;
  const char * D.20357;
  const char * D.20358;
  void * (*<T2d69>) (struct MonoVTable *, size_t, gboolean) D.20359;
  void * D.20360;
  long unsigned int D.20361;
  int D.20362;
  _Bool D.20363;
  long int D.20364;
  long int D.20365;
  struct FILE * gc_debug_file.52;
  void * D.20374;
  void * * p;

  D.20350 = size + 7;
  size = D.20350 & 18446744073709551608;
  pthread_mutex_lock (&gc_mutex);
  if (size > 8000) goto <D.20351>; else goto <D.20352>;
  <D.20351>:
  p = sgen_los_alloc_large_inner (vtable, size);
  goto <D.20353>;
  <D.20352>:
  if (0 != 0) goto <D.20354>; else goto <D.20355>;
  <D.20354>:
  D.20356 = vtable->klass;
  D.20357 = D.20356->name_space;
  D.20356 = vtable->klass;
  D.20358 = D.20356->name;
  monoeg_g_log (0B, 4, "class %s:%s is not initialized", D.20357, D.20358);
  <D.19916>:
  goto <D.19916>;
  <D.20355>:
  D.20359 = major_collector.alloc_small_pinned_obj;
  D.20360 = vtable->gc_descr;
  D.20361 = (long unsigned int) D.20360;
  D.20362 = sgen_gc_descr_has_references (D.20361);
  p = D.20359 (vtable, size, D.20362);
  <D.20353>:
  D.20363 = p != 0B;
  D.20364 = (long int) D.20363;
  D.20365 = __builtin_expect (D.20364, 1);
  if (D.20365 != 0) goto <D.20366>; else goto <D.20367>;
  <D.20366>:
  if (0 != 0) goto <D.20368>; else goto <D.20369>;
  <D.20368>:
  gc_debug_file.52 = gc_debug_file;
  D.20356 = vtable->klass;
  D.20358 = D.20356->name;
  fprintf (gc_debug_file.52, "Allocated pinned object %p, vtable: %p (%s), size: %zd\n", p, vtable, D.20358, size);
  gc_debug_file.52 = gc_debug_file;
  fflush (gc_debug_file.52);
  <D.20369>:
  if (size > 8000) goto <D.20371>; else goto <D.20372>;
  <D.20371>:
  goto <D.20373>;
  <D.20372>:
  <D.20373>:
  <D.20367>:
  sgen_gc_unlock ();
  D.20374 = p;
  return D.20374;
}


sgen_gc_descr_has_references (mword desc)
{
  long unsigned int D.20376;
  gboolean D.20379;
  long unsigned int D.20380;
  long unsigned int D.20383;

  D.20376 = desc & 4294901767;
  if (D.20376 == 1) goto <D.20377>; else goto <D.20378>;
  <D.20377>:
  D.20379 = 0;
  return D.20379;
  <D.20378>:
  D.20380 = desc & 49159;
  if (D.20380 == 4) goto <D.20381>; else goto <D.20382>;
  <D.20381>:
  D.20379 = 0;
  return D.20379;
  <D.20382>:
  D.20383 = desc & 7;
  if (D.20383 == 7) goto <D.20384>; else goto <D.20385>;
  <D.20384>:
  D.20379 = 0;
  return D.20379;
  <D.20385>:
  D.20379 = 1;
  return D.20379;
}


mono_gc_alloc_mature (struct MonoVTable * vtable)
{
  struct MonoClass * D.20387;
  int D.20388;
  int D.20389;
  int D.20390;
  long unsigned int D.20391;
  long unsigned int D.20392;
  _Bool D.20393;
  long int D.20394;
  long int D.20395;
  void * D.20398;
  void * * res;
  size_t size;

  D.20387 = vtable->klass;
  D.20388 = D.20387->instance_size;
  D.20389 = D.20388 + 7;
  D.20390 = D.20389 & -8;
  size = (size_t) D.20390;
  pthread_mutex_lock (&gc_mutex);
  res = alloc_degraded (vtable, size, 1);
  sgen_gc_unlock ();
  D.20387 = vtable->klass;
  D.20391 = BIT_FIELD_REF <*D.20387, 64, 256>;
  D.20392 = D.20391 & 2097152;
  D.20393 = D.20392 != 0;
  D.20394 = (long int) D.20393;
  D.20395 = __builtin_expect (D.20394, 0);
  if (D.20395 != 0) goto <D.20396>; else goto <D.20397>;
  <D.20396>:
  mono_object_register_finalizer (res);
  <D.20397>:
  D.20398 = res;
  return D.20398;
}


mono_gc_alloc_fixed (size_t size, void * descr)
{
  void * D.20402;
  int D.20403;
  void * res;

  res = calloc (1, size);
  if (res == 0B) goto <D.20400>; else goto <D.20401>;
  <D.20400>:
  D.20402 = 0B;
  return D.20402;
  <D.20401>:
  D.20403 = mono_gc_register_root (res, size, descr);
  if (D.20403 == 0) goto <D.20404>; else goto <D.20405>;
  <D.20404>:
  free (res);
  res = 0B;
  <D.20405>:
  D.20402 = res;
  return D.20402;
}


mono_gc_free_fixed (void * addr)
{
  mono_gc_deregister_root (addr);
  free (addr);
}


sgen_init_tlab_info (struct SgenThreadInfo * info)
{
  info->tlab_start_addr = &tlab_start;
  info->tlab_next_addr = &tlab_next;
  info->tlab_temp_end_addr = &tlab_temp_end;
  info->tlab_real_end_addr = &tlab_real_end;
  tlab_next_addr = &tlab_next;
}


sgen_clear_tlabs ()
{
  struct MonoLinkedListSet * D.20407;
  struct MonoLinkedListSetNode * D.20408;
  long unsigned int D.20409;
  char * * D.20412;
  char * * D.20413;
  char * * D.20414;
  char * * D.20415;
  struct SgenThreadInfo * info;

  {
    struct MonoLinkedListSetNode * __cur;

    D.20407 = mono_thread_info_list_head ();
    __cur = D.20407->head;
    goto <D.19939>;
    <D.19938>:
    D.20408 = __cur->next;
    D.20409 = mono_lls_pointer_get_mark (D.20408);
    if (D.20409 == 0) goto <D.20410>; else goto <D.20411>;
    <D.20410>:
    info = __cur;
    D.20412 = info->tlab_start_addr;
    *D.20412 = 0B;
    D.20413 = info->tlab_next_addr;
    *D.20413 = 0B;
    D.20414 = info->tlab_temp_end_addr;
    *D.20414 = 0B;
    D.20415 = info->tlab_real_end_addr;
    *D.20415 = 0B;
    <D.20411>:
    D.20408 = __cur->next;
    __cur = mono_lls_pointer_unmask (D.20408);
    <D.19939>:
    if (__cur != 0B) goto <D.19938>; else goto <D.19940>;
    <D.19940>:
  }
}


mono_lls_pointer_get_mark (void * n)
{
  uintptr_t D.20416;
  long unsigned int n.53;

  n.53 = (long unsigned int) n;
  D.20416 = n.53 & 1;
  return D.20416;
}


mono_lls_pointer_unmask (void * p)
{
  void * D.20419;
  long unsigned int p.54;
  long unsigned int D.20421;

  p.54 = (long unsigned int) p;
  D.20421 = p.54 & 18446744073709551612;
  D.20419 = (void *) D.20421;
  return D.20419;
}


mono_gc_get_managed_allocator (struct MonoClass * klass, gboolean for_box)
{
  struct MonoMethod * D.20426;
  unsigned int collect_before_allocs.55;
  int D.20430;
  int D.20433;
  unsigned int D.20434;
  unsigned int tlab_size.56;
  long unsigned int D.20440;
  long unsigned int D.20441;
  <unnamed type> D.20443;
  unsigned int D.20444;
  unsigned char D.20445;
  unsigned char D.20448;
  long unsigned int D.20452;
  long unsigned int D.20453;
  long unsigned int D.20454;
  struct MonoType * D.20456;
  int D.20457;
  int tlab_next_offset;
  int tlab_temp_end_offset;

  tlab_next_offset = -1;
  tlab_temp_end_offset = -1;
  __asm__("lis	%0,tlab_next@tprel@ha
addi	%0,%0, tlab_next@tprel@l
" : "=r" tlab_next_offset);
  __asm__("lis	%0,tlab_temp_end@tprel@ha
addi	%0,%0, tlab_temp_end@tprel@l
" : "=r" tlab_temp_end_offset);
  if (tlab_next_offset == -1) goto <D.20423>; else goto <D.20425>;
  <D.20425>:
  if (tlab_temp_end_offset == -1) goto <D.20423>; else goto <D.20424>;
  <D.20423>:
  D.20426 = 0B;
  return D.20426;
  <D.20424>:
  collect_before_allocs.55 = collect_before_allocs;
  if (collect_before_allocs.55 != 0) goto <D.20428>; else goto <D.20429>;
  <D.20428>:
  D.20426 = 0B;
  return D.20426;
  <D.20429>:
  D.20430 = mono_runtime_has_tls_get ();
  if (D.20430 == 0) goto <D.20431>; else goto <D.20432>;
  <D.20431>:
  D.20426 = 0B;
  return D.20426;
  <D.20432>:
  D.20433 = klass->instance_size;
  D.20434 = (unsigned int) D.20433;
  tlab_size.56 = tlab_size;
  if (D.20434 > tlab_size.56) goto <D.20436>; else goto <D.20437>;
  <D.20436>:
  D.20426 = 0B;
  return D.20426;
  <D.20437>:
  D.20440 = BIT_FIELD_REF <*klass, 64, 256>;
  D.20441 = D.20440 & 6291456;
  if (D.20441 != 0) goto <D.20438>; else goto <D.20442>;
  <D.20442>:
  D.20443 = mono_profiler_get_events ();
  D.20444 = D.20443 & 128;
  if (D.20444 != 0) goto <D.20438>; else goto <D.20439>;
  <D.20438>:
  D.20426 = 0B;
  return D.20426;
  <D.20439>:
  D.20445 = klass->rank;
  if (D.20445 != 0) goto <D.20446>; else goto <D.20447>;
  <D.20446>:
  D.20426 = 0B;
  return D.20426;
  <D.20447>:
  D.20448 = klass->byval_arg.type;
  if (D.20448 == 14) goto <D.20449>; else goto <D.20450>;
  <D.20449>:
  D.20426 = mono_gc_get_managed_allocator_by_type (3);
  return D.20426;
  <D.20450>:
  D.20433 = klass->instance_size;
  D.20452 = (long unsigned int) D.20433;
  D.20453 = D.20452 + 7;
  D.20454 = D.20453 & 18446744073709551608;
  if (D.20454 <= 7999) goto <D.20455>; else goto <D.20451>;
  <D.20455>:
  D.20456 = &klass->byval_arg;
  D.20457 = mono_class_is_open_constructed_type (D.20456);
  if (D.20457 == 0) goto <D.20458>; else goto <D.20451>;
  <D.20458>:
  D.20426 = mono_gc_get_managed_allocator_by_type (2);
  return D.20426;
  <D.20451>:
  D.20426 = mono_gc_get_managed_allocator_by_type (0);
  return D.20426;
}


mono_gc_get_managed_array_allocator (struct MonoClass * klass)
{
  struct MonoMethod * D.20463;
  unsigned char D.20464;
  int D.20467;
  <unnamed type> D.20470;
  unsigned int D.20471;
  int has_per_allocation_action.57;
  int iftmp.58;
  int D.20481;
  long unsigned int D.20483;
  long unsigned int D.20484;
  _Bool D.20485;
  long int D.20486;
  long int D.20487;
  int tlab_next_offset;
  int tlab_temp_end_offset;

  tlab_next_offset = -1;
  tlab_temp_end_offset = -1;
  __asm__("lis	%0,tlab_next@tprel@ha
addi	%0,%0, tlab_next@tprel@l
" : "=r" tlab_next_offset);
  __asm__("lis	%0,tlab_temp_end@tprel@ha
addi	%0,%0, tlab_temp_end@tprel@l
" : "=r" tlab_temp_end_offset);
  if (tlab_next_offset == -1) goto <D.20460>; else goto <D.20462>;
  <D.20462>:
  if (tlab_temp_end_offset == -1) goto <D.20460>; else goto <D.20461>;
  <D.20460>:
  D.20463 = 0B;
  return D.20463;
  <D.20461>:
  D.20464 = klass->rank;
  if (D.20464 != 1) goto <D.20465>; else goto <D.20466>;
  <D.20465>:
  D.20463 = 0B;
  return D.20463;
  <D.20466>:
  D.20467 = mono_runtime_has_tls_get ();
  if (D.20467 == 0) goto <D.20468>; else goto <D.20469>;
  <D.20468>:
  D.20463 = 0B;
  return D.20463;
  <D.20469>:
  D.20470 = mono_profiler_get_events ();
  D.20471 = D.20470 & 128;
  if (D.20471 != 0) goto <D.20472>; else goto <D.20473>;
  <D.20472>:
  D.20463 = 0B;
  return D.20463;
  <D.20473>:
  has_per_allocation_action.57 = has_per_allocation_action;
  if (has_per_allocation_action.57 != 0) goto <D.20475>; else goto <D.20476>;
  <D.20475>:
  D.20463 = 0B;
  return D.20463;
  <D.20476>:
  D.20481 = mono_class_has_finalizer (klass);
  if (D.20481 != 0) goto <D.20478>; else goto <D.20482>;
  <D.20482>:
  D.20483 = BIT_FIELD_REF <*klass, 64, 256>;
  D.20484 = D.20483 & 4194304;
  if (D.20484 != 0) goto <D.20478>; else goto <D.20479>;
  <D.20478>:
  iftmp.58 = 1;
  goto <D.20480>;
  <D.20479>:
  iftmp.58 = 0;
  <D.20480>:
  D.20485 = iftmp.58 != 0;
  D.20486 = (long int) D.20485;
  D.20487 = __builtin_expect (D.20486, 0);
  if (D.20487 != 0) goto <D.20488>; else goto <D.20489>;
  <D.20488>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "sgen-alloc.c", 1037, "!mono_class_has_finalizer (klass) && !mono_class_is_marshalbyref (klass)");
  <D.20489>:
  D.20463 = mono_gc_get_managed_allocator_by_type (1);
  return D.20463;
}


sgen_set_use_managed_allocator (gboolean flag)
{
  use_managed_allocator = flag;
}


mono_gc_get_managed_allocator_by_type (int atype)
{
  int use_managed_allocator.59;
  struct MonoMethod * D.20494;
  int D.20495;
  struct MonoMethod * D.20500;
  struct MonoMethod * res;

  use_managed_allocator.59 = use_managed_allocator;
  if (use_managed_allocator.59 == 0) goto <D.20492>; else goto <D.20493>;
  <D.20492>:
  D.20494 = 0B;
  return D.20494;
  <D.20493>:
  D.20495 = mono_runtime_has_tls_get ();
  if (D.20495 == 0) goto <D.20496>; else goto <D.20497>;
  <D.20496>:
  D.20494 = 0B;
  return D.20494;
  <D.20497>:
  res = alloc_method_cache[atype];
  if (res != 0B) goto <D.20498>; else goto <D.20499>;
  <D.20498>:
  D.20494 = res;
  return D.20494;
  <D.20499>:
  res = create_allocator (atype);
  pthread_mutex_lock (&gc_mutex);
  D.20500 = alloc_method_cache[atype];
  if (D.20500 != 0B) goto <D.20501>; else goto <D.20502>;
  <D.20501>:
  mono_free_method (res);
  res = alloc_method_cache[atype];
  goto <D.20503>;
  <D.20502>:
  mono_memory_barrier ();
  alloc_method_cache[atype] = res;
  <D.20503>:
  sgen_gc_unlock ();
  D.20494 = res;
  return D.20494;
}


create_allocator (int atype)
{
  _Bool D.20505;
  long int D.20506;
  long int D.20507;
  _Bool D.20510;
  long int D.20511;
  long int D.20512;
  int registered.60;
  struct MonoMethodSignature * D.20518;
  struct MonoMethodSignature * D.20519;
  struct MonoMethodSignature * D.20520;
  struct MonoImage * D.20533;
  unsigned int num_params.61;
  struct MonoClass * D.20537;
  struct MonoType * D.20538;
  struct MonoClass * D.20539;
  struct MonoType * D.20540;
  struct MonoClass * D.20541;
  struct MonoType * D.20542;
  struct MonoClass * D.20544;
  struct MonoType * D.20545;
  unsigned int size_var.62;
  unsigned int D.20553;
  unsigned int pos.63;
  int D.20555;
  unsigned int D.20556;
  unsigned int D.20557;
  int D.20558;
  unsigned int D.20559;
  unsigned int D.20560;
  unsigned int D.20561;
  struct MonoClass * D.20562;
  struct MonoClass * D.20563;
  _Bool D.20564;
  long int D.20565;
  long int D.20566;
  int D.20569;
  unsigned int D.20570;
  _Bool D.20571;
  long int D.20572;
  long int D.20573;
  _Bool D.20576;
  long int D.20577;
  long int D.20578;
  int D.20581;
  unsigned int D.20582;
  unsigned int D.20583;
  unsigned int D.20584;
  unsigned int pos_leave.64;
  unsigned int tlab_next_addr_var.65;
  unsigned int p_var.66;
  unsigned int new_next_var.67;
  struct MonoMethodHeader * D.20612;
  struct MonoMethod * D.20613;
  int p_var;
  int size_var;
  guint32 slowpath_branch;
  guint32 max_size_branch;
  struct MonoMethodBuilder * mb;
  struct MonoMethod * res;
  struct MonoMethodSignature * csig;
  static gboolean registered = 0;
  int tlab_next_addr_var;
  int new_next_var;
  int num_params;
  int i;
  const char * name;
  struct AllocatorWrapperInfo * info;
  int tlab_next_addr_offset;
  int tlab_temp_end_offset;

  name = 0B;
  tlab_next_addr_offset = -1;
  tlab_temp_end_offset = -1;
  __asm__("lis	%0,tlab_next_addr@tprel@ha
addi	%0,%0, tlab_next_addr@tprel@l
" : "=r" tlab_next_addr_offset);
  __asm__("lis	%0,tlab_temp_end@tprel@ha
addi	%0,%0, tlab_temp_end@tprel@l
" : "=r" tlab_temp_end_offset);
  mono_tls_key_set_offset (5, tlab_next_addr_offset);
  mono_tls_key_set_offset (6, tlab_temp_end_offset);
  D.20505 = tlab_next_addr_offset == -1;
  D.20506 = (long int) D.20505;
  D.20507 = __builtin_expect (D.20506, 0);
  if (D.20507 != 0) goto <D.20508>; else goto <D.20509>;
  <D.20508>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "sgen-alloc.c", 710, "tlab_next_addr_offset != -1");
  <D.20509>:
  D.20510 = tlab_temp_end_offset == -1;
  D.20511 = (long int) D.20510;
  D.20512 = __builtin_expect (D.20511, 0);
  if (D.20512 != 0) goto <D.20513>; else goto <D.20514>;
  <D.20513>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "sgen-alloc.c", 711, "tlab_temp_end_offset != -1");
  <D.20514>:
  registered.60 = registered;
  if (registered.60 == 0) goto <D.20516>; else goto <D.20517>;
  <D.20516>:
  D.20518 = mono_create_icall_signature ("object ptr int");
  mono_register_jit_icall (mono_gc_alloc_obj, "mono_gc_alloc_obj", D.20518, 0);
  D.20519 = mono_create_icall_signature ("object ptr int int");
  mono_register_jit_icall (mono_gc_alloc_vector, "mono_gc_alloc_vector", D.20519, 0);
  D.20520 = mono_create_icall_signature ("object ptr int int32");
  mono_register_jit_icall (mono_gc_alloc_string, "mono_gc_alloc_string", D.20520, 0);
  registered = 1;
  <D.20517>:
  if (atype == 2) goto <D.20521>; else goto <D.20522>;
  <D.20521>:
  num_params = 1;
  name = "AllocSmall";
  goto <D.20523>;
  <D.20522>:
  if (atype == 0) goto <D.20524>; else goto <D.20525>;
  <D.20524>:
  num_params = 1;
  name = "Alloc";
  goto <D.20526>;
  <D.20525>:
  if (atype == 1) goto <D.20527>; else goto <D.20528>;
  <D.20527>:
  num_params = 2;
  name = "AllocVector";
  goto <D.20529>;
  <D.20528>:
  if (atype == 3) goto <D.20530>; else goto <D.20531>;
  <D.20530>:
  num_params = 2;
  name = "AllocString";
  goto <D.20532>;
  <D.20531>:
  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "sgen-alloc.c", 734);
  <D.20532>:
  <D.20529>:
  <D.20526>:
  <D.20523>:
  D.20533 = mono_defaults.corlib;
  num_params.61 = (unsigned int) num_params;
  csig = mono_metadata_signature_alloc (D.20533, num_params.61);
  if (atype == 3) goto <D.20535>; else goto <D.20536>;
  <D.20535>:
  D.20537 = mono_defaults.string_class;
  D.20538 = &D.20537->byval_arg;
  csig->ret = D.20538;
  D.20539 = mono_defaults.int_class;
  D.20540 = &D.20539->byval_arg;
  csig->params[0] = D.20540;
  D.20541 = mono_defaults.int32_class;
  D.20542 = &D.20541->byval_arg;
  csig->params[1] = D.20542;
  goto <D.20543>;
  <D.20536>:
  D.20544 = mono_defaults.object_class;
  D.20545 = &D.20544->byval_arg;
  csig->ret = D.20545;
  i = 0;
  goto <D.19962>;
  <D.19961>:
  D.20539 = mono_defaults.int_class;
  D.20540 = &D.20539->byval_arg;
  csig->params[i] = D.20540;
  i = i + 1;
  <D.19962>:
  if (i < num_params) goto <D.19961>; else goto <D.19963>;
  <D.19963>:
  <D.20543>:
  D.20544 = mono_defaults.object_class;
  mb = mono_mb_new (D.20544, name, 28);
  D.20541 = mono_defaults.int32_class;
  D.20542 = &D.20541->byval_arg;
  size_var = mono_mb_add_local (mb, D.20542);
  if (atype == 0) goto <D.20546>; else goto <D.20549>;
  <D.20549>:
  if (atype == 2) goto <D.20546>; else goto <D.20547>;
  <D.20546>:
  mono_mb_emit_ldarg (mb, 0);
  mono_mb_emit_icon (mb, 0);
  mono_mb_emit_byte (mb, 88);
  mono_mb_emit_byte (mb, 77);
  mono_mb_emit_icon (mb, 28);
  mono_mb_emit_byte (mb, 88);
  mono_mb_emit_byte (mb, 75);
  size_var.62 = (unsigned int) size_var;
  mono_mb_emit_stloc (mb, size_var.62);
  goto <D.20548>;
  <D.20547>:
  if (atype == 1) goto <D.20551>; else goto <D.20552>;
  <D.20551>:
  {
    struct MonoExceptionClause * clause;
    int pos;
    int pos_leave;
    struct MonoClass * oom_exc_class;
    struct MonoMethod * ctor;

    mono_mb_emit_ldarg (mb, 1);
    mono_mb_emit_icon (mb, 2147483647);
    D.20553 = mono_mb_emit_short_branch (mb, 54);
    pos = (int) D.20553;
    mono_mb_emit_exception (mb, "OverflowException", 0B);
    pos.63 = (unsigned int) pos;
    mono_mb_patch_short_branch (mb, pos.63);
    D.20533 = mono_defaults.corlib;
    clause = mono_image_alloc0 (D.20533, 32);
    D.20555 = mono_mb_get_label (mb);
    D.20556 = (unsigned int) D.20555;
    clause->try_offset = D.20556;
    mono_mb_emit_ldarg (mb, 0);
    mono_mb_emit_icon (mb, 0);
    mono_mb_emit_byte (mb, 88);
    mono_mb_emit_byte (mb, 77);
    mono_mb_emit_icon (mb, 128);
    mono_mb_emit_byte (mb, 88);
    mono_mb_emit_byte (mb, 75);
    mono_mb_emit_ldarg (mb, 1);
    mono_mb_emit_byte (mb, 217);
    mono_mb_emit_icon (mb, 32);
    mono_mb_emit_byte (mb, 215);
    size_var.62 = (unsigned int) size_var;
    mono_mb_emit_stloc (mb, size_var.62);
    D.20557 = mono_mb_emit_branch (mb, 221);
    pos_leave = (int) D.20557;
    clause->flags = 0;
    D.20558 = mono_mb_get_pos (mb);
    D.20559 = (unsigned int) D.20558;
    D.20560 = clause->try_offset;
    D.20561 = D.20559 - D.20560;
    clause->try_len = D.20561;
    D.20533 = mono_defaults.corlib;
    D.20562 = mono_class_from_name (D.20533, "System", "OverflowException");
    clause->data.catch_class = D.20562;
    D.20563 = clause->data.catch_class;
    D.20564 = D.20563 == 0B;
    D.20565 = (long int) D.20564;
    D.20566 = __builtin_expect (D.20565, 0);
    if (D.20566 != 0) goto <D.20567>; else goto <D.20568>;
    <D.20567>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "sgen-alloc.c", 803, "clause->data.catch_class");
    <D.20568>:
    D.20569 = mono_mb_get_label (mb);
    D.20570 = (unsigned int) D.20569;
    clause->handler_offset = D.20570;
    D.20533 = mono_defaults.corlib;
    oom_exc_class = mono_class_from_name (D.20533, "System", "OutOfMemoryException");
    D.20571 = oom_exc_class == 0B;
    D.20572 = (long int) D.20571;
    D.20573 = __builtin_expect (D.20572, 0);
    if (D.20573 != 0) goto <D.20574>; else goto <D.20575>;
    <D.20574>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "sgen-alloc.c", 808, "oom_exc_class");
    <D.20575>:
    ctor = mono_class_get_method_from_name (oom_exc_class, ".ctor", 0);
    D.20576 = ctor == 0B;
    D.20577 = (long int) D.20576;
    D.20578 = __builtin_expect (D.20577, 0);
    if (D.20578 != 0) goto <D.20579>; else goto <D.20580>;
    <D.20579>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "sgen-alloc.c", 810, "ctor");
    <D.20580>:
    mono_mb_emit_byte (mb, 38);
    mono_mb_emit_op (mb, 115, ctor);
    mono_mb_emit_byte (mb, 122);
    D.20581 = mono_mb_get_pos (mb);
    D.20582 = (unsigned int) D.20581;
    D.20583 = clause->handler_offset;
    D.20584 = D.20582 - D.20583;
    clause->handler_len = D.20584;
    mono_mb_set_clauses (mb, 1, clause);
    pos_leave.64 = (unsigned int) pos_leave;
    mono_mb_patch_branch (mb, pos_leave.64);
  }
  goto <D.20586>;
  <D.20552>:
  if (atype == 3) goto <D.20587>; else goto <D.20588>;
  <D.20587>:
  mono_mb_emit_ldarg (mb, 1);
  mono_mb_emit_icon (mb, 1);
  mono_mb_emit_byte (mb, 98);
  mono_mb_emit_icon (mb, 26);
  mono_mb_emit_byte (mb, 88);
  size_var.62 = (unsigned int) size_var;
  mono_mb_emit_stloc (mb, size_var.62);
  goto <D.20589>;
  <D.20588>:
  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "sgen-alloc.c", 831);
  <D.20589>:
  <D.20586>:
  <D.20548>:
  size_var.62 = (unsigned int) size_var;
  mono_mb_emit_ldloc (mb, size_var.62);
  mono_mb_emit_icon (mb, 7);
  mono_mb_emit_byte (mb, 88);
  mono_mb_emit_icon (mb, -8);
  mono_mb_emit_byte (mb, 95);
  size_var.62 = (unsigned int) size_var;
  mono_mb_emit_stloc (mb, size_var.62);
  if (atype != 2) goto <D.20590>; else goto <D.20591>;
  <D.20590>:
  size_var.62 = (unsigned int) size_var;
  mono_mb_emit_ldloc (mb, size_var.62);
  mono_mb_emit_icon (mb, 8000);
  max_size_branch = mono_mb_emit_short_branch (mb, 53);
  <D.20591>:
  D.20539 = mono_defaults.int_class;
  D.20540 = &D.20539->byval_arg;
  tlab_next_addr_var = mono_mb_add_local (mb, D.20540);
  mono_mb_emit_byte (mb, 240);
  mono_mb_emit_byte (mb, 13);
  mono_mb_emit_i4 (mb, 5);
  tlab_next_addr_var.65 = (unsigned int) tlab_next_addr_var;
  mono_mb_emit_stloc (mb, tlab_next_addr_var.65);
  D.20539 = mono_defaults.int_class;
  D.20540 = &D.20539->byval_arg;
  p_var = mono_mb_add_local (mb, D.20540);
  tlab_next_addr_var.65 = (unsigned int) tlab_next_addr_var;
  mono_mb_emit_ldloc (mb, tlab_next_addr_var.65);
  mono_mb_emit_byte (mb, 77);
  p_var.66 = (unsigned int) p_var;
  mono_mb_emit_stloc (mb, p_var.66);
  D.20539 = mono_defaults.int_class;
  D.20540 = &D.20539->byval_arg;
  new_next_var = mono_mb_add_local (mb, D.20540);
  p_var.66 = (unsigned int) p_var;
  mono_mb_emit_ldloc (mb, p_var.66);
  size_var.62 = (unsigned int) size_var;
  mono_mb_emit_ldloc (mb, size_var.62);
  mono_mb_emit_byte (mb, 211);
  mono_mb_emit_byte (mb, 88);
  new_next_var.67 = (unsigned int) new_next_var;
  mono_mb_emit_stloc (mb, new_next_var.67);
  new_next_var.67 = (unsigned int) new_next_var;
  mono_mb_emit_ldloc (mb, new_next_var.67);
  mono_mb_emit_byte (mb, 240);
  mono_mb_emit_byte (mb, 13);
  mono_mb_emit_i4 (mb, 6);
  slowpath_branch = mono_mb_emit_short_branch (mb, 55);
  if (atype != 2) goto <D.20595>; else goto <D.20596>;
  <D.20595>:
  mono_mb_patch_short_branch (mb, max_size_branch);
  <D.20596>:
  mono_mb_emit_byte (mb, 240);
  mono_mb_emit_byte (mb, 12);
  mono_mb_emit_ldarg (mb, 0);
  size_var.62 = (unsigned int) size_var;
  mono_mb_emit_ldloc (mb, size_var.62);
  if (atype == 0) goto <D.20597>; else goto <D.20600>;
  <D.20600>:
  if (atype == 2) goto <D.20597>; else goto <D.20598>;
  <D.20597>:
  mono_mb_emit_icall (mb, mono_gc_alloc_obj);
  goto <D.20599>;
  <D.20598>:
  if (atype == 1) goto <D.20601>; else goto <D.20602>;
  <D.20601>:
  mono_mb_emit_ldarg (mb, 1);
  mono_mb_emit_icall (mb, mono_gc_alloc_vector);
  goto <D.20603>;
  <D.20602>:
  if (atype == 3) goto <D.20604>; else goto <D.20605>;
  <D.20604>:
  mono_mb_emit_ldarg (mb, 1);
  mono_mb_emit_icall (mb, mono_gc_alloc_string);
  goto <D.20606>;
  <D.20605>:
  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "sgen-alloc.c", 898);
  <D.20606>:
  <D.20603>:
  <D.20599>:
  mono_mb_emit_byte (mb, 42);
  mono_mb_patch_short_branch (mb, slowpath_branch);
  tlab_next_addr_var.65 = (unsigned int) tlab_next_addr_var;
  mono_mb_emit_ldloc (mb, tlab_next_addr_var.65);
  new_next_var.67 = (unsigned int) new_next_var;
  mono_mb_emit_ldloc (mb, new_next_var.67);
  mono_mb_emit_byte (mb, 223);
  mono_mb_emit_byte (mb, 240);
  mono_mb_emit_op (mb, 16, 0B);
  p_var.66 = (unsigned int) p_var;
  mono_mb_emit_ldloc (mb, p_var.66);
  mono_mb_emit_ldarg (mb, 0);
  mono_mb_emit_byte (mb, 223);
  if (atype == 1) goto <D.20607>; else goto <D.20608>;
  <D.20607>:
  p_var.66 = (unsigned int) p_var;
  mono_mb_emit_ldloc (mb, p_var.66);
  mono_mb_emit_ldflda (mb, 24);
  mono_mb_emit_ldarg (mb, 1);
  mono_mb_emit_byte (mb, 84);
  goto <D.20609>;
  <D.20608>:
  if (atype == 3) goto <D.20610>; else goto <D.20611>;
  <D.20610>:
  p_var.66 = (unsigned int) p_var;
  mono_mb_emit_ldloc (mb, p_var.66);
  mono_mb_emit_icon (mb, 16);
  mono_mb_emit_byte (mb, 88);
  mono_mb_emit_ldarg (mb, 1);
  mono_mb_emit_byte (mb, 84);
  p_var.66 = (unsigned int) p_var;
  mono_mb_emit_ldloc (mb, p_var.66);
  size_var.62 = (unsigned int) size_var;
  mono_mb_emit_ldloc (mb, size_var.62);
  mono_mb_emit_icon (mb, 2);
  mono_mb_emit_byte (mb, 89);
  mono_mb_emit_byte (mb, 88);
  mono_mb_emit_icon (mb, 0);
  mono_mb_emit_byte (mb, 83);
  <D.20611>:
  <D.20609>:
  mono_mb_emit_byte (mb, 240);
  mono_mb_emit_op (mb, 16, 0B);
  p_var.66 = (unsigned int) p_var;
  mono_mb_emit_ldloc (mb, p_var.66);
  mono_mb_emit_byte (mb, 42);
  res = mono_mb_create_method (mb, csig, 8);
  mono_mb_free (mb);
  D.20612 = mono_method_get_header (res);
  D.20612->init_locals = 0;
  D.20533 = mono_defaults.corlib;
  info = mono_image_alloc0 (D.20533, 16);
  info->gc_name = "sgen";
  info->alloc_type = atype;
  mono_marshal_set_wrapper_info (res, info);
  D.20613 = res;
  return D.20613;
}


mono_gc_get_managed_allocator_types ()
{
  guint32 D.20615;

  D.20615 = 4;
  return D.20615;
}


sgen_is_managed_allocator (struct MonoMethod * method)
{
  struct MonoMethod * D.20617;
  gboolean D.20620;
  int i;

  i = 0;
  goto <D.19995>;
  <D.19994>:
  D.20617 = alloc_method_cache[i];
  if (D.20617 == method) goto <D.20618>; else goto <D.20619>;
  <D.20618>:
  D.20620 = 1;
  return D.20620;
  <D.20619>:
  i = i + 1;
  <D.19995>:
  if (i <= 3) goto <D.19994>; else goto <D.19996>;
  <D.19996>:
  D.20620 = 0;
  return D.20620;
}


sgen_has_managed_allocator ()
{
  struct MonoMethod * D.20622;
  gboolean D.20625;
  int i;

  i = 0;
  goto <D.20002>;
  <D.20001>:
  D.20622 = alloc_method_cache[i];
  if (D.20622 != 0B) goto <D.20623>; else goto <D.20624>;
  <D.20623>:
  D.20625 = 1;
  return D.20625;
  <D.20624>:
  i = i + 1;
  <D.20002>:
  if (i <= 3) goto <D.20001>; else goto <D.20003>;
  <D.20003>:
  D.20625 = 0;
  return D.20625;
}