mono_gc_alloc_obj (struct MonoVTable * vtable, size_t size)
{
  int has_per_allocation_action.0;
  _Bool D.19482;
  long int D.19483;
  long int D.19484;
  unsigned int verify_before_allocs.1;
  unsigned int current_alloc.2;
  unsigned int D.19491;
  unsigned int collect_before_allocs.3;
  unsigned int D.19497;
  struct GCMemSection * nursery_section.4;
  struct SgenThreadInfo * sgen_thread_info.5;
  void * D.19506;
  _Bool D.19507;
  long int D.19508;
  long int D.19509;
  void * res;

  has_per_allocation_action.0 = has_per_allocation_action;
  D.19482 = has_per_allocation_action.0 != 0;
  D.19483 = (long int) D.19482;
  D.19484 = __builtin_expect (D.19483, 0);
  if (D.19484 != 0) goto <D.19485>; else goto <D.19486>;
  <D.19485>:
  {
    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.19488>; else goto <D.19489>;
    <D.19488>:
    current_alloc.2 = (unsigned int) current_alloc;
    verify_before_allocs.1 = verify_before_allocs;
    D.19491 = current_alloc.2 % verify_before_allocs.1;
    if (D.19491 == 0) goto <D.19492>; else goto <D.19493>;
    <D.19492>:
    sgen_check_whole_heap_stw ();
    <D.19493>:
    <D.19489>:
    collect_before_allocs.3 = collect_before_allocs;
    if (collect_before_allocs.3 != 0) goto <D.19495>; else goto <D.19496>;
    <D.19495>:
    current_alloc.2 = (unsigned int) current_alloc;
    collect_before_allocs.3 = collect_before_allocs;
    D.19497 = current_alloc.2 % collect_before_allocs.3;
    if (D.19497 == 0) goto <D.19498>; else goto <D.19499>;
    <D.19498>:
    nursery_section.4 = nursery_section;
    if (nursery_section.4 != 0B) goto <D.19501>; else goto <D.19502>;
    <D.19501>:
    pthread_mutex_lock (&gc_mutex);
    sgen_perform_collection (0, 0, "collect-before-alloc-triggered", 1);
    sgen_gc_unlock ();
    <D.19502>:
    <D.19499>:
    <D.19496>:
  }
  <D.19486>:
  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.19504>; else goto <D.19505>;
  <D.19504>:
  sgen_thread_info.5 = sgen_thread_info;
  sgen_thread_info.5->in_critical_region = 0;
  D.19506 = res;
  return D.19506;
  <D.19505>:
  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.19507 = res == 0B;
  D.19508 = (long int) D.19507;
  D.19509 = __builtin_expect (D.19508, 0);
  if (D.19509 != 0) goto <D.19510>; else goto <D.19511>;
  <D.19510>:
  D.19506 = mono_gc_out_of_memory (size);
  return D.19506;
  <D.19511>:
  D.19506 = res;
  return D.19506;
}


InterlockedIncrement (volatile gint32 * val)
{
  gint32 D.19513;
  unsigned int D.19514;

  D.19514 = __sync_add_and_fetch_4 (val, 1);
  D.19513 = (gint32) D.19514;
  return D.19513;
}


mono_memory_barrier ()
{
  __sync_synchronize ();
}


mono_gc_try_alloc_obj_nolock (struct MonoVTable * vtable, size_t size)
{
  long unsigned int D.19516;
  void * D.19519;
  _Bool D.19520;
  long int D.19521;
  long int D.19522;
  void * D.19527;
  unsigned int tlab_size.6;
  long unsigned int D.19529;
  _Bool D.19530;
  long int D.19531;
  long int D.19532;
  <unnamed type> nursery_clear_policy.7;
  long int real_end.8;
  long int p.9;
  long int D.19543;
  _Bool D.19544;
  long int D.19545;
  long int D.19546;
  char * tlab_temp_end.10;
  _Bool D.19550;
  long int D.19551;
  long int D.19552;
  char * tlab_next.11;
  char * D.19556;
  char * tlab_real_end.12;
  char * tlab_temp_end.13;
  struct FILE * gc_debug_file.14;
  long int D.19570;
  char * tlab_next.15;
  long unsigned int alloc_size.16;
  char * tlab_real_end.17;
  long unsigned int D.19576;
  char * tlab_temp_end.18;
  struct MonoClass * D.19582;
  const char * D.19583;
  void * D.19586;
  _Bool D.19587;
  long int D.19588;
  long int D.19589;
  void * * p;
  char * new_next;

  D.19516 = size + 7;
  size = D.19516 & 18446744073709551608;
  if (0 != 0) goto <D.19517>; else goto <D.19518>;
  <D.19517>:
  monoeg_g_log (0B, 4, "Object too small");
  <D.19350>:
  goto <D.19350>;
  <D.19518>:
  D.19519 = vtable->gc_descr;
  D.19520 = D.19519 == 0B;
  D.19521 = (long int) D.19520;
  D.19522 = __builtin_expect (D.19521, 0);
  if (D.19522 != 0) goto <D.19523>; else goto <D.19524>;
  <D.19523>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "sgen-alloc.c", 352, "vtable->gc_descr");
  <D.19524>:
  if (size > 8000) goto <D.19525>; else goto <D.19526>;
  <D.19525>:
  D.19527 = 0B;
  return D.19527;
  <D.19526>:
  tlab_size.6 = tlab_size;
  D.19529 = (long unsigned int) tlab_size.6;
  D.19530 = D.19529 < size;
  D.19531 = (long int) D.19530;
  D.19532 = __builtin_expect (D.19531, 0);
  if (D.19532 != 0) goto <D.19533>; else goto <D.19534>;
  <D.19533>:
  p = sgen_nursery_alloc (size);
  if (p == 0B) goto <D.19535>; else goto <D.19536>;
  <D.19535>:
  D.19527 = 0B;
  return D.19527;
  <D.19536>:
  sgen_set_nursery_scan_start (p);
  nursery_clear_policy.7 = nursery_clear_policy;
  if (nursery_clear_policy.7 == 1) goto <D.19538>; else goto <D.19539>;
  <D.19538>:
  memset (p, 0, size);
  <D.19539>:
  goto <D.19540>;
  <D.19534>:
  {
    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.19543 = real_end.8 - p.9;
    available_in_tlab = (int) D.19543;
    D.19544 = new_next < real_end;
    D.19545 = (long int) D.19544;
    D.19546 = __builtin_expect (D.19545, 1);
    if (D.19546 != 0) goto <D.19547>; else goto <D.19548>;
    <D.19547>:
    tlab_next = new_next;
    tlab_temp_end.10 = tlab_temp_end;
    D.19550 = new_next >= tlab_temp_end.10;
    D.19551 = (long int) D.19550;
    D.19552 = __builtin_expect (D.19551, 0);
    if (D.19552 != 0) goto <D.19553>; else goto <D.19554>;
    <D.19553>:
    sgen_set_nursery_scan_start (new_next);
    tlab_next.11 = tlab_next;
    D.19556 = tlab_next.11 + 8192;
    tlab_real_end.12 = tlab_real_end;
    tlab_temp_end.13 = MIN_EXPR <D.19556, tlab_real_end.12>;
    tlab_temp_end = tlab_temp_end.13;
    if (0 != 0) goto <D.19559>; else goto <D.19560>;
    <D.19559>:
    tlab_temp_end.10 = tlab_temp_end;
    tlab_next.11 = tlab_next;
    gc_debug_file.14 = gc_debug_file;
    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.19560>:
    <D.19554>:
    goto <D.19562>;
    <D.19548>:
    if (available_in_tlab > 512) goto <D.19563>; else goto <D.19564>;
    <D.19563>:
    p = sgen_nursery_alloc (size);
    if (p == 0B) goto <D.19565>; else goto <D.19566>;
    <D.19565>:
    D.19527 = 0B;
    return D.19527;
    <D.19566>:
    nursery_clear_policy.7 = nursery_clear_policy;
    if (nursery_clear_policy.7 == 1) goto <D.19567>; else goto <D.19568>;
    <D.19567>:
    memset (p, 0, size);
    <D.19568>:
    goto <D.19569>;
    <D.19564>:
    {
      size_t alloc_size;

      try
        {
          alloc_size = 0;
          D.19570 = (long int) available_in_tlab;
          sgen_nursery_retire_region (p, D.19570);
          tlab_size.6 = tlab_size;
          D.19529 = (long unsigned int) tlab_size.6;
          new_next = sgen_nursery_alloc_range (D.19529, size, &alloc_size);
          p = new_next;
          if (p == 0B) goto <D.19571>; else goto <D.19572>;
          <D.19571>:
          D.19527 = 0B;
          return D.19527;
          <D.19572>:
          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.19576 = MIN_EXPR <alloc_size.16, 8192>;
          tlab_temp_end.18 = new_next + D.19576;
          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.19578>; else goto <D.19579>;
          <D.19578>:
          alloc_size.16 = alloc_size;
          memset (new_next, 0, alloc_size.16);
          <D.19579>:
        }
      finally
        {
          alloc_size = {CLOBBER};
        }
    }
    <D.19569>:
    <D.19562>:
  }
  <D.19540>:
  if (0 != 0) goto <D.19580>; else goto <D.19581>;
  <D.19580>:
  D.19582 = vtable->klass;
  D.19583 = D.19582->name;
  gc_debug_file.14 = gc_debug_file;
  fprintf (gc_debug_file.14, "Allocated object %p, vtable: %p (%s), size: %zd\n", p, vtable, D.19583, size);
  gc_debug_file.14 = gc_debug_file;
  fflush (gc_debug_file.14);
  <D.19581>:
  if (0 != 0) goto <D.19584>; else goto <D.19585>;
  <D.19584>:
  <D.19585>:
  D.19586 = *p;
  D.19587 = D.19586 != 0B;
  D.19588 = (long int) D.19587;
  D.19589 = __builtin_expect (D.19588, 0);
  if (D.19589 != 0) goto <D.19590>; else goto <D.19591>;
  <D.19590>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "sgen-alloc.c", 425, "*p == NULL");
  <D.19591>:
  *p = vtable;
  D.19527 = p;
  return D.19527;
}


sgen_set_nursery_scan_start (char * p)
{
  long int p.19;
  struct GCMemSection * nursery_section.20;
  char * D.19597;
  long int D.19598;
  long int D.19599;
  long int D.19600;
  char * * D.19601;
  long unsigned int D.19602;
  long unsigned int D.19603;
  char * * D.19604;
  _Bool D.19605;
  _Bool D.19606;
  _Bool D.19607;
  int idx;
  char * old;

  p.19 = (long int) p;
  nursery_section.20 = nursery_section;
  D.19597 = nursery_section.20->data;
  D.19598 = (long int) D.19597;
  D.19599 = p.19 - D.19598;
  D.19600 = D.19599 / 8192;
  idx = (int) D.19600;
  nursery_section.20 = nursery_section;
  D.19601 = nursery_section.20->scan_starts;
  D.19602 = (long unsigned int) idx;
  D.19603 = D.19602 * 8;
  D.19604 = D.19601 + D.19603;
  old = *D.19604;
  D.19605 = old == 0B;
  D.19606 = old > p;
  D.19607 = D.19605 | D.19606;
  if (D.19607 != 0) goto <D.19608>; else goto <D.19609>;
  <D.19608>:
  nursery_section.20 = nursery_section;
  D.19601 = nursery_section.20->scan_starts;
  D.19602 = (long unsigned int) idx;
  D.19603 = D.19602 * 8;
  D.19604 = D.19601 + D.19603;
  *D.19604 = p;
  <D.19609>:
}


memset (void * __dest, int __ch, size_t __len)
{
  int D.19612;
  int D.19617;
  void * D.19619;
  long unsigned int D.19620;

  D.19612 = __builtin_constant_p (__len);
  if (D.19612 != 0) goto <D.19613>; else goto <D.19614>;
  <D.19613>:
  if (__len == 0) goto <D.19615>; else goto <D.19616>;
  <D.19615>:
  D.19617 = __builtin_constant_p (__ch);
  if (D.19617 == 0) goto <D.19610>; else goto <D.19618>;
  <D.19618>:
  if (__ch != 0) goto <D.19610>; else goto <D.19611>;
  <D.19610>:
  __warn_memset_zero_len ();
  D.19619 = __dest;
  return D.19619;
  <D.19611>:
  <D.19616>:
  <D.19614>:
  D.19620 = __builtin_object_size (__dest, 0);
  D.19619 = __builtin___memset_chk (__dest, __ch, __len, D.19620);
  return D.19619;
}


mono_gc_alloc_obj_nolock (struct MonoVTable * vtable, size_t size)
{
  long unsigned int D.19625;
  void * D.19626;
  _Bool D.19627;
  long int D.19628;
  long int D.19629;
  int has_per_allocation_action.21;
  _Bool D.19633;
  long int D.19634;
  long int D.19635;
  unsigned int collect_before_allocs.22;
  unsigned int current_alloc.23;
  unsigned int D.19642;
  struct GCMemSection * nursery_section.24;
  int degraded_mode.25;
  int D.19651;
  unsigned int verify_before_allocs.26;
  unsigned int D.19660;
  char * tlab_temp_end.27;
  _Bool D.19667;
  long int D.19668;
  long int D.19669;
  struct MonoClass * D.19674;
  const char * D.19675;
  struct FILE * gc_debug_file.28;
  void * D.19679;
  _Bool D.19680;
  long int D.19681;
  long int D.19682;
  void * D.19685;
  char * tlab_next.29;
  char * tlab_real_end.30;
  sizetype D.19690;
  char * tlab_next.31;
  int sgen_nursery_size.32;
  long int tlab_real_end.33;
  long int tlab_next.34;
  long int D.19699;
  unsigned int tlab_size.35;
  long unsigned int D.19704;
  <unnamed type> nursery_clear_policy.36;
  char * tlab_start.37;
  long unsigned int D.19722;
  long unsigned int D.19723;
  long int D.19724;
  long int D.19725;
  long unsigned int alloc_size.38;
  char * tlab_real_end.39;
  long unsigned int D.19736;
  char * tlab_temp_end.40;
  char * tlab_next.41;
  char * D.19742;
  char * tlab_temp_end.42;
  _Bool D.19746;
  long int D.19747;
  long int D.19748;
  void * * p;
  char * new_next;

  if (size <= 8000) goto <D.19622>; else goto <D.19623>;
  <D.19622>:
  goto <D.19624>;
  <D.19623>:
  <D.19624>:
  D.19625 = size + 7;
  size = D.19625 & 18446744073709551608;
  D.19626 = vtable->gc_descr;
  D.19627 = D.19626 == 0B;
  D.19628 = (long int) D.19627;
  D.19629 = __builtin_expect (D.19628, 0);
  if (D.19629 != 0) goto <D.19630>; else goto <D.19631>;
  <D.19630>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "sgen-alloc.c", 172, "vtable->gc_descr");
  <D.19631>:
  has_per_allocation_action.21 = has_per_allocation_action;
  D.19633 = has_per_allocation_action.21 != 0;
  D.19634 = (long int) D.19633;
  D.19635 = __builtin_expect (D.19634, 0);
  if (D.19635 != 0) goto <D.19636>; else goto <D.19637>;
  <D.19636>:
  {
    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.19639>; else goto <D.19640>;
    <D.19639>:
    current_alloc.23 = (unsigned int) current_alloc;
    collect_before_allocs.22 = collect_before_allocs;
    D.19642 = current_alloc.23 % collect_before_allocs.22;
    if (D.19642 == 0) goto <D.19643>; else goto <D.19644>;
    <D.19643>:
    nursery_section.24 = nursery_section;
    if (nursery_section.24 != 0B) goto <D.19646>; else goto <D.19647>;
    <D.19646>:
    sgen_perform_collection (0, 0, "collect-before-alloc-triggered", 1);
    degraded_mode.25 = degraded_mode;
    if (degraded_mode.25 == 0) goto <D.19649>; else goto <D.19650>;
    <D.19649>:
    D.19651 = sgen_can_alloc_size (size);
    if (D.19651 != 0) goto <D.19652>; else goto <D.19653>;
    <D.19652>:
    if (size <= 8000) goto <D.19654>; else goto <D.19655>;
    <D.19654>:
    monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "sgen-alloc.c", 183);
    <D.19655>:
    <D.19653>:
    <D.19650>:
    <D.19647>:
    <D.19644>:
    goto <D.19656>;
    <D.19640>:
    verify_before_allocs.26 = verify_before_allocs;
    if (verify_before_allocs.26 != 0) goto <D.19658>; else goto <D.19659>;
    <D.19658>:
    current_alloc.23 = (unsigned int) current_alloc;
    verify_before_allocs.26 = verify_before_allocs;
    D.19660 = current_alloc.23 % verify_before_allocs.26;
    if (D.19660 == 0) goto <D.19661>; else goto <D.19662>;
    <D.19661>:
    sgen_check_whole_heap_stw ();
    <D.19662>:
    <D.19659>:
    <D.19656>:
  }
  <D.19637>:
  if (size > 8000) goto <D.19663>; else goto <D.19664>;
  <D.19663>:
  p = sgen_los_alloc_large_inner (vtable, size);
  goto <D.19665>;
  <D.19664>:
  p = tlab_next;
  new_next = p + size;
  tlab_next = new_next;
  tlab_temp_end.27 = tlab_temp_end;
  D.19667 = new_next < tlab_temp_end.27;
  D.19668 = (long int) D.19667;
  D.19669 = __builtin_expect (D.19668, 1);
  if (D.19669 != 0) goto <D.19670>; else goto <D.19671>;
  <D.19670>:
  if (0 != 0) goto <D.19672>; else goto <D.19673>;
  <D.19672>:
  D.19674 = vtable->klass;
  D.19675 = D.19674->name;
  gc_debug_file.28 = gc_debug_file;
  fprintf (gc_debug_file.28, "Allocated object %p, vtable: %p (%s), size: %zd\n", p, vtable, D.19675, size);
  gc_debug_file.28 = gc_debug_file;
  fflush (gc_debug_file.28);
  <D.19673>:
  if (0 != 0) goto <D.19677>; else goto <D.19678>;
  <D.19677>:
  <D.19678>:
  D.19679 = *p;
  D.19680 = D.19679 != 0B;
  D.19681 = (long int) D.19680;
  D.19682 = __builtin_expect (D.19681, 0);
  if (D.19682 != 0) goto <D.19683>; else goto <D.19684>;
  <D.19683>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "sgen-alloc.c", 225, "*p == NULL");
  <D.19684>:
  *p = vtable;
  D.19685 = p;
  return D.19685;
  <D.19671>:
  tlab_next.29 = tlab_next;
  tlab_real_end.30 = tlab_real_end;
  if (tlab_next.29 >= tlab_real_end.30) goto <D.19688>; else goto <D.19689>;
  <D.19688>:
  {
    int available_in_tlab;

    tlab_next.29 = tlab_next;
    D.19690 = -size;
    tlab_next.31 = tlab_next.29 + D.19690;
    tlab_next = tlab_next.31;
    degraded_mode.25 = degraded_mode;
    if (degraded_mode.25 != 0) goto <D.19692>; else goto <D.19693>;
    <D.19692>:
    degraded_mode.25 = degraded_mode;
    sgen_nursery_size.32 = sgen_nursery_size;
    if (degraded_mode.25 < sgen_nursery_size.32) goto <D.19695>; else goto <D.19696>;
    <D.19695>:
    D.19685 = alloc_degraded (vtable, size, 0);
    return D.19685;
    <D.19696>:
    <D.19693>:
    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.19699 = tlab_real_end.33 - tlab_next.34;
    available_in_tlab = (int) D.19699;
    tlab_size.35 = tlab_size;
    D.19704 = (long unsigned int) tlab_size.35;
    if (D.19704 < size) goto <D.19700>; else goto <D.19705>;
    <D.19705>:
    if (available_in_tlab > 512) goto <D.19700>; else goto <D.19701>;
    <D.19700>:
    <D.19339>:
    p = sgen_nursery_alloc (size);
    if (p == 0B) goto <D.19706>; else goto <D.19707>;
    <D.19706>:
    sgen_ensure_free_space (size);
    degraded_mode.25 = degraded_mode;
    if (degraded_mode.25 != 0) goto <D.19708>; else goto <D.19709>;
    <D.19708>:
    D.19685 = alloc_degraded (vtable, size, 0);
    return D.19685;
    <D.19709>:
    p = sgen_nursery_alloc (size);
    <D.19707>:
    if (p == 0B) goto <D.19339>; else goto <D.19340>;
    <D.19340>:
    if (p == 0B) goto <D.19710>; else goto <D.19711>;
    <D.19710>:
    if (1 != 0) goto <D.19712>; else goto <D.19713>;
    <D.19712>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "sgen-alloc.c", 273, "0");
    <D.19713>:
    <D.19711>:
    nursery_clear_policy.36 = nursery_clear_policy;
    if (nursery_clear_policy.36 == 1) goto <D.19715>; else goto <D.19716>;
    <D.19715>:
    memset (p, 0, size);
    <D.19716>:
    goto <D.19702>;
    <D.19701>:
    {
      size_t alloc_size;

      try
        {
          alloc_size = 0;
          tlab_start.37 = tlab_start;
          if (tlab_start.37 != 0B) goto <D.19718>; else goto <D.19719>;
          <D.19718>:
          if (0 != 0) goto <D.19720>; else goto <D.19721>;
          <D.19720>:
          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.19699 = tlab_real_end.33 - tlab_next.34;
          D.19722 = (long unsigned int) D.19699;
          D.19723 = D.19722 - size;
          D.19724 = (long int) D.19723;
          tlab_real_end.30 = tlab_real_end;
          tlab_start.37 = tlab_start;
          gc_debug_file.28 = gc_debug_file;
          fprintf (gc_debug_file.28, "Retire TLAB: %p-%p [%ld]\n", tlab_start.37, tlab_real_end.30, D.19724);
          gc_debug_file.28 = gc_debug_file;
          fflush (gc_debug_file.28);
          <D.19721>:
          <D.19719>:
          D.19725 = (long int) available_in_tlab;
          sgen_nursery_retire_region (p, D.19725);
          <D.19342>:
          tlab_size.35 = tlab_size;
          D.19704 = (long unsigned int) tlab_size.35;
          p = sgen_nursery_alloc_range (D.19704, size, &alloc_size);
          if (p == 0B) goto <D.19726>; else goto <D.19727>;
          <D.19726>:
          tlab_size.35 = tlab_size;
          D.19704 = (long unsigned int) tlab_size.35;
          sgen_ensure_free_space (D.19704);
          degraded_mode.25 = degraded_mode;
          if (degraded_mode.25 != 0) goto <D.19728>; else goto <D.19729>;
          <D.19728>:
          D.19685 = alloc_degraded (vtable, size, 0);
          return D.19685;
          <D.19729>:
          tlab_size.35 = tlab_size;
          D.19704 = (long unsigned int) tlab_size.35;
          p = sgen_nursery_alloc_range (D.19704, size, &alloc_size);
          <D.19727>:
          if (p == 0B) goto <D.19342>; else goto <D.19343>;
          <D.19343>:
          if (p == 0B) goto <D.19730>; else goto <D.19731>;
          <D.19730>:
          if (1 != 0) goto <D.19732>; else goto <D.19733>;
          <D.19732>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "sgen-alloc.c", 298, "0");
          <D.19733>:
          <D.19731>:
          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.19736 = MIN_EXPR <alloc_size.38, 8192>;
          tlab_temp_end.40 = tlab_start.37 + D.19736;
          tlab_temp_end = tlab_temp_end.40;
          nursery_clear_policy.36 = nursery_clear_policy;
          if (nursery_clear_policy.36 == 1) goto <D.19738>; else goto <D.19739>;
          <D.19738>:
          alloc_size.38 = alloc_size;
          tlab_start.37 = tlab_start;
          memset (tlab_start.37, 0, alloc_size.38);
          <D.19739>:
          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.19702>:
  }
  goto <D.19741>;
  <D.19689>:
  sgen_set_nursery_scan_start (p);
  tlab_next.29 = tlab_next;
  D.19742 = tlab_next.29 + 8192;
  tlab_real_end.30 = tlab_real_end;
  tlab_temp_end.42 = MIN_EXPR <D.19742, tlab_real_end.30>;
  tlab_temp_end = tlab_temp_end.42;
  if (0 != 0) goto <D.19744>; else goto <D.19745>;
  <D.19744>:
  tlab_temp_end.27 = tlab_temp_end;
  tlab_next.29 = tlab_next;
  gc_debug_file.28 = gc_debug_file;
  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.19745>:
  <D.19741>:
  <D.19665>:
  D.19746 = p != 0B;
  D.19747 = (long int) D.19746;
  D.19748 = __builtin_expect (D.19747, 1);
  if (D.19748 != 0) goto <D.19749>; else goto <D.19750>;
  <D.19749>:
  if (0 != 0) goto <D.19751>; else goto <D.19752>;
  <D.19751>:
  D.19674 = vtable->klass;
  D.19675 = D.19674->name;
  gc_debug_file.28 = gc_debug_file;
  fprintf (gc_debug_file.28, "Allocated object %p, vtable: %p (%s), size: %zd\n", p, vtable, D.19675, size);
  gc_debug_file.28 = gc_debug_file;
  fflush (gc_debug_file.28);
  <D.19752>:
  if (0 != 0) goto <D.19753>; else goto <D.19754>;
  <D.19753>:
  if (size > 8000) goto <D.19755>; else goto <D.19756>;
  <D.19755>:
  goto <D.19757>;
  <D.19756>:
  <D.19757>:
  <D.19754>:
  *p = vtable;
  <D.19750>:
  D.19685 = p;
  return D.19685;
}


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;
  int num_degraded.47;
  _Bool D.19770;
  _Bool D.19771;
  _Bool D.19772;
  struct _IO_FILE * stderr.48;
  int D.19779;
  int D.19781;
  _Bool D.19784;
  int D.19785;
  void * (*<T2ce2>) (struct MonoVTable *, size_t) D.19786;
  void * D.19790;
  static int last_major_gc_warned = -1;
  static int num_degraded = 0;
  void * p;

  if (for_mature == 0) goto <D.19761>; else goto <D.19762>;
  <D.19761>:
  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.19765>; else goto <D.19766>;
  <D.19765>:
  num_degraded.45 = num_degraded;
  num_degraded.46 = num_degraded.45 + 1;
  num_degraded = num_degraded.46;
  num_degraded.47 = num_degraded;
  D.19770 = num_degraded.47 == 1;
  D.19771 = num_degraded.47 == 3;
  D.19772 = D.19770 | D.19771;
  if (D.19772 != 0) goto <D.19773>; else goto <D.19774>;
  <D.19773>:
  stderr.48 = stderr;
  fprintf (stderr.48, "Warning: Degraded allocation.  Consider increasing nursery-size if the warning persists.\n");
  goto <D.19776>;
  <D.19774>:
  num_degraded.45 = num_degraded;
  if (num_degraded.45 == 10) goto <D.19777>; else goto <D.19778>;
  <D.19777>:
  stderr.48 = stderr;
  fprintf (stderr.48, "Warning: Repeated degraded allocation.  Consider increasing nursery-size.\n");
  <D.19778>:
  <D.19776>:
  stat_major_gcs.44 = stat_major_gcs;
  last_major_gc_warned = stat_major_gcs.44;
  <D.19766>:
  D.19779 = (int) size;
  InterlockedExchangeAdd (&degraded_mode, D.19779);
  sgen_ensure_free_space (size);
  goto <D.19780>;
  <D.19762>:
  D.19781 = sgen_need_major_collection (size);
  if (D.19781 != 0) goto <D.19782>; else goto <D.19783>;
  <D.19782>:
  D.19784 = for_mature == 0;
  D.19785 = (int) D.19784;
  sgen_perform_collection (size, 1, "mature allocation failure", D.19785);
  <D.19783>:
  <D.19780>:
  D.19786 = major_collector.alloc_degraded;
  p = D.19786 (vtable, size);
  if (for_mature != 0) goto <D.19787>; else goto <D.19788>;
  <D.19787>:
  goto <D.19789>;
  <D.19788>:
  <D.19789>:
  D.19790 = p;
  return D.19790;
}


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

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


InterlockedExchangeAdd (volatile gint32 * val, gint32 add)
{
  gint32 D.19794;
  unsigned int add.49;
  unsigned int D.19796;

  add.49 = (unsigned int) add;
  D.19796 = __sync_fetch_and_add_4 (val, add.49);
  D.19794 = (gint32) D.19796;
  return D.19794;
}


mono_gc_alloc_vector (struct MonoVTable * vtable, size_t size, uintptr_t max_length)
{
  struct SgenThreadInfo * sgen_thread_info.50;
  unsigned int D.19801;
  void * D.19802;
  _Bool D.19803;
  long int D.19804;
  long int D.19805;
  struct MonoArray * arr;

  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.19799>; else goto <D.19800>;
  <D.19799>:
  D.19801 = (unsigned int) max_length;
  arr->max_length = D.19801;
  sgen_thread_info.50 = sgen_thread_info;
  sgen_thread_info.50->in_critical_region = 0;
  D.19802 = arr;
  return D.19802;
  <D.19800>:
  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.19803 = arr == 0B;
  D.19804 = (long int) D.19803;
  D.19805 = __builtin_expect (D.19804, 0);
  if (D.19805 != 0) goto <D.19806>; else goto <D.19807>;
  <D.19806>:
  sgen_gc_unlock ();
  D.19802 = mono_gc_out_of_memory (size);
  return D.19802;
  <D.19807>:
  D.19801 = (unsigned int) max_length;
  arr->max_length = D.19801;
  sgen_gc_unlock ();
  D.19802 = arr;
  return D.19802;
}


mono_gc_alloc_array (struct MonoVTable * vtable, size_t size, uintptr_t max_length, uintptr_t bounds_size)
{
  struct SgenThreadInfo * sgen_thread_info.51;
  unsigned int D.19812;
  sizetype D.19813;
  void * D.19814;
  _Bool D.19815;
  long int D.19816;
  long int D.19817;
  struct MonoArray * arr;
  struct MonoArrayBounds * bounds;

  sgen_thread_info.51 = sgen_thread_info;
  sgen_thread_info.51->in_critical_region = 1;
  mono_memory_barrier ();
  arr = mono_gc_try_alloc_obj_nolock (vtable, size);
  if (arr != 0B) goto <D.19810>; else goto <D.19811>;
  <D.19810>:
  D.19812 = (unsigned int) max_length;
  arr->max_length = D.19812;
  D.19813 = size - bounds_size;
  bounds = arr + D.19813;
  arr->bounds = bounds;
  sgen_thread_info.51 = sgen_thread_info;
  sgen_thread_info.51->in_critical_region = 0;
  D.19814 = arr;
  return D.19814;
  <D.19811>:
  sgen_thread_info.51 = sgen_thread_info;
  sgen_thread_info.51->in_critical_region = 0;
  pthread_mutex_lock (&gc_mutex);
  arr = mono_gc_alloc_obj_nolock (vtable, size);
  D.19815 = arr == 0B;
  D.19816 = (long int) D.19815;
  D.19817 = __builtin_expect (D.19816, 0);
  if (D.19817 != 0) goto <D.19818>; else goto <D.19819>;
  <D.19818>:
  sgen_gc_unlock ();
  D.19814 = mono_gc_out_of_memory (size);
  return D.19814;
  <D.19819>:
  D.19812 = (unsigned int) max_length;
  arr->max_length = D.19812;
  D.19813 = size - bounds_size;
  bounds = arr + D.19813;
  arr->bounds = bounds;
  sgen_gc_unlock ();
  D.19814 = arr;
  return D.19814;
}


mono_gc_alloc_string (struct MonoVTable * vtable, size_t size, gint32 len)
{
  struct SgenThreadInfo * sgen_thread_info.52;
  void * D.19824;
  _Bool D.19825;
  long int D.19826;
  long int D.19827;
  struct MonoString * str;

  sgen_thread_info.52 = sgen_thread_info;
  sgen_thread_info.52->in_critical_region = 1;
  mono_memory_barrier ();
  str = mono_gc_try_alloc_obj_nolock (vtable, size);
  if (str != 0B) goto <D.19822>; else goto <D.19823>;
  <D.19822>:
  str->length = len;
  sgen_thread_info.52 = sgen_thread_info;
  sgen_thread_info.52->in_critical_region = 0;
  D.19824 = str;
  return D.19824;
  <D.19823>:
  sgen_thread_info.52 = sgen_thread_info;
  sgen_thread_info.52->in_critical_region = 0;
  pthread_mutex_lock (&gc_mutex);
  str = mono_gc_alloc_obj_nolock (vtable, size);
  D.19825 = str == 0B;
  D.19826 = (long int) D.19825;
  D.19827 = __builtin_expect (D.19826, 0);
  if (D.19827 != 0) goto <D.19828>; else goto <D.19829>;
  <D.19828>:
  sgen_gc_unlock ();
  D.19824 = mono_gc_out_of_memory (size);
  return D.19824;
  <D.19829>:
  str->length = len;
  sgen_gc_unlock ();
  D.19824 = str;
  return D.19824;
}


mono_gc_alloc_pinned_obj (struct MonoVTable * vtable, size_t size)
{
  long unsigned int D.19831;
  struct MonoClass * D.19837;
  const char * D.19838;
  const char * D.19839;
  void * (*<T2cde>) (struct MonoVTable *, size_t, gboolean) D.19840;
  void * D.19841;
  long unsigned int D.19842;
  int D.19843;
  _Bool D.19844;
  long int D.19845;
  long int D.19846;
  struct FILE * gc_debug_file.53;
  void * D.19855;
  void * * p;

  D.19831 = size + 7;
  size = D.19831 & 18446744073709551608;
  pthread_mutex_lock (&gc_mutex);
  if (size > 8000) goto <D.19832>; else goto <D.19833>;
  <D.19832>:
  p = sgen_los_alloc_large_inner (vtable, size);
  goto <D.19834>;
  <D.19833>:
  if (0 != 0) goto <D.19835>; else goto <D.19836>;
  <D.19835>:
  D.19837 = vtable->klass;
  D.19838 = D.19837->name;
  D.19837 = vtable->klass;
  D.19839 = D.19837->name_space;
  monoeg_g_log (0B, 4, "class %s:%s is not initialized", D.19839, D.19838);
  <D.19386>:
  goto <D.19386>;
  <D.19836>:
  D.19840 = major_collector.alloc_small_pinned_obj;
  D.19841 = vtable->gc_descr;
  D.19842 = (long unsigned int) D.19841;
  D.19843 = sgen_gc_descr_has_references (D.19842);
  p = D.19840 (vtable, size, D.19843);
  <D.19834>:
  D.19844 = p != 0B;
  D.19845 = (long int) D.19844;
  D.19846 = __builtin_expect (D.19845, 1);
  if (D.19846 != 0) goto <D.19847>; else goto <D.19848>;
  <D.19847>:
  if (0 != 0) goto <D.19849>; else goto <D.19850>;
  <D.19849>:
  D.19837 = vtable->klass;
  D.19838 = D.19837->name;
  gc_debug_file.53 = gc_debug_file;
  fprintf (gc_debug_file.53, "Allocated pinned object %p, vtable: %p (%s), size: %zd\n", p, vtable, D.19838, size);
  gc_debug_file.53 = gc_debug_file;
  fflush (gc_debug_file.53);
  <D.19850>:
  if (size > 8000) goto <D.19852>; else goto <D.19853>;
  <D.19852>:
  goto <D.19854>;
  <D.19853>:
  <D.19854>:
  <D.19848>:
  sgen_gc_unlock ();
  D.19855 = p;
  return D.19855;
}


sgen_gc_descr_has_references (mword desc)
{
  long unsigned int D.19857;
  gboolean D.19860;
  long unsigned int D.19861;
  long unsigned int D.19864;

  D.19857 = desc & 4294901767;
  if (D.19857 == 1) goto <D.19858>; else goto <D.19859>;
  <D.19858>:
  D.19860 = 0;
  return D.19860;
  <D.19859>:
  D.19861 = desc & 49159;
  if (D.19861 == 4) goto <D.19862>; else goto <D.19863>;
  <D.19862>:
  D.19860 = 0;
  return D.19860;
  <D.19863>:
  D.19864 = desc & 7;
  if (D.19864 == 7) goto <D.19865>; else goto <D.19866>;
  <D.19865>:
  D.19860 = 0;
  return D.19860;
  <D.19866>:
  D.19860 = 1;
  return D.19860;
}


mono_gc_alloc_mature (struct MonoVTable * vtable)
{
  struct MonoClass * D.19868;
  int D.19869;
  int D.19870;
  int D.19871;
  unsigned char D.19872;
  unsigned char D.19873;
  _Bool D.19874;
  long int D.19875;
  long int D.19876;
  void * D.19879;
  void * * res;
  size_t size;

  D.19868 = vtable->klass;
  D.19869 = D.19868->instance_size;
  D.19870 = D.19869 + 7;
  D.19871 = D.19870 & -8;
  size = (size_t) D.19871;
  pthread_mutex_lock (&gc_mutex);
  res = alloc_degraded (vtable, size, 1);
  sgen_gc_unlock ();
  D.19868 = vtable->klass;
  D.19872 = BIT_FIELD_REF <*D.19868, 8, 272>;
  D.19873 = D.19872 & 32;
  D.19874 = D.19873 != 0;
  D.19875 = (long int) D.19874;
  D.19876 = __builtin_expect (D.19875, 0);
  if (D.19876 != 0) goto <D.19877>; else goto <D.19878>;
  <D.19877>:
  mono_object_register_finalizer (res);
  <D.19878>:
  D.19879 = res;
  return D.19879;
}


mono_gc_alloc_fixed (size_t size, void * descr)
{
  void * D.19883;
  int D.19884;
  void * res;

  res = calloc (1, size);
  if (res == 0B) goto <D.19881>; else goto <D.19882>;
  <D.19881>:
  D.19883 = 0B;
  return D.19883;
  <D.19882>:
  D.19884 = mono_gc_register_root (res, size, descr);
  if (D.19884 == 0) goto <D.19885>; else goto <D.19886>;
  <D.19885>:
  free (res);
  res = 0B;
  <D.19886>:
  D.19883 = res;
  return D.19883;
}


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.19888;
  struct MonoLinkedListSetNode * D.19889;
  long unsigned int D.19890;
  char * * D.19893;
  char * * D.19894;
  char * * D.19895;
  char * * D.19896;
  struct SgenThreadInfo * info;

  {
    struct MonoLinkedListSetNode * __cur;

    D.19888 = mono_thread_info_list_head ();
    __cur = D.19888->head;
    goto <D.19409>;
    <D.19408>:
    D.19889 = __cur->next;
    D.19890 = mono_lls_pointer_get_mark (D.19889);
    if (D.19890 == 0) goto <D.19891>; else goto <D.19892>;
    <D.19891>:
    info = __cur;
    D.19893 = info->tlab_start_addr;
    *D.19893 = 0B;
    D.19894 = info->tlab_next_addr;
    *D.19894 = 0B;
    D.19895 = info->tlab_temp_end_addr;
    *D.19895 = 0B;
    D.19896 = info->tlab_real_end_addr;
    *D.19896 = 0B;
    <D.19892>:
    D.19889 = __cur->next;
    __cur = mono_lls_pointer_unmask (D.19889);
    <D.19409>:
    if (__cur != 0B) goto <D.19408>; else goto <D.19410>;
    <D.19410>:
  }
}


mono_lls_pointer_get_mark (void * n)
{
  uintptr_t D.19897;
  long unsigned int n.54;

  n.54 = (long unsigned int) n;
  D.19897 = n.54 & 1;
  return D.19897;
}


mono_lls_pointer_unmask (void * p)
{
  void * D.19900;
  long unsigned int p.55;
  long unsigned int D.19902;

  p.55 = (long unsigned int) p;
  D.19902 = p.55 & 18446744073709551612;
  D.19900 = (void *) D.19902;
  return D.19900;
}


mono_gc_get_managed_allocator (struct MonoClass * klass, gboolean for_box)
{
  _Bool D.19904;
  _Bool D.19905;
  _Bool D.19906;
  struct MonoMethod * D.19909;
  unsigned int collect_before_allocs.56;
  int D.19913;
  int D.19916;
  unsigned int D.19917;
  unsigned int tlab_size.57;
  unsigned char D.19923;
  unsigned char D.19924;
  <unnamed type> D.19926;
  unsigned int D.19927;
  unsigned char D.19928;
  unsigned char D.19931;
  long unsigned int D.19935;
  long unsigned int D.19936;
  long unsigned int D.19937;
  struct MonoType * D.19939;
  int D.19940;
  int tlab_next_offset;
  int tlab_temp_end_offset;

  tlab_next_offset = -1;
  tlab_temp_end_offset = -1;
  {
    guint64 foo;

    __asm__("movq $tlab_next@TPOFF, %0" : "=r" foo);
    tlab_next_offset = (int) foo;
  }
  {
    guint64 foo;

    __asm__("movq $tlab_temp_end@TPOFF, %0" : "=r" foo);
    tlab_temp_end_offset = (int) foo;
  }
  D.19904 = tlab_next_offset == -1;
  D.19905 = tlab_temp_end_offset == -1;
  D.19906 = D.19904 | D.19905;
  if (D.19906 != 0) goto <D.19907>; else goto <D.19908>;
  <D.19907>:
  D.19909 = 0B;
  return D.19909;
  <D.19908>:
  collect_before_allocs.56 = collect_before_allocs;
  if (collect_before_allocs.56 != 0) goto <D.19911>; else goto <D.19912>;
  <D.19911>:
  D.19909 = 0B;
  return D.19909;
  <D.19912>:
  D.19913 = mono_runtime_has_tls_get ();
  if (D.19913 == 0) goto <D.19914>; else goto <D.19915>;
  <D.19914>:
  D.19909 = 0B;
  return D.19909;
  <D.19915>:
  D.19916 = klass->instance_size;
  D.19917 = (unsigned int) D.19916;
  tlab_size.57 = tlab_size;
  if (D.19917 > tlab_size.57) goto <D.19919>; else goto <D.19920>;
  <D.19919>:
  D.19909 = 0B;
  return D.19909;
  <D.19920>:
  D.19923 = BIT_FIELD_REF <*klass, 8, 272>;
  D.19924 = D.19923 & 96;
  if (D.19924 != 0) goto <D.19921>; else goto <D.19925>;
  <D.19925>:
  D.19926 = mono_profiler_get_events ();
  D.19927 = D.19926 & 128;
  if (D.19927 != 0) goto <D.19921>; else goto <D.19922>;
  <D.19921>:
  D.19909 = 0B;
  return D.19909;
  <D.19922>:
  D.19928 = klass->rank;
  if (D.19928 != 0) goto <D.19929>; else goto <D.19930>;
  <D.19929>:
  D.19909 = 0B;
  return D.19909;
  <D.19930>:
  D.19931 = klass->byval_arg.type;
  if (D.19931 == 14) goto <D.19932>; else goto <D.19933>;
  <D.19932>:
  D.19909 = mono_gc_get_managed_allocator_by_type (3);
  return D.19909;
  <D.19933>:
  D.19916 = klass->instance_size;
  D.19935 = (long unsigned int) D.19916;
  D.19936 = D.19935 + 7;
  D.19937 = D.19936 & 18446744073709551608;
  if (D.19937 <= 7999) goto <D.19938>; else goto <D.19934>;
  <D.19938>:
  D.19939 = &klass->byval_arg;
  D.19940 = mono_class_is_open_constructed_type (D.19939);
  if (D.19940 == 0) goto <D.19941>; else goto <D.19934>;
  <D.19941>:
  D.19909 = mono_gc_get_managed_allocator_by_type (2);
  return D.19909;
  <D.19934>:
  D.19909 = mono_gc_get_managed_allocator_by_type (0);
  return D.19909;
}


mono_gc_get_managed_array_allocator (struct MonoClass * klass)
{
  _Bool D.19943;
  _Bool D.19944;
  _Bool D.19945;
  struct MonoMethod * D.19948;
  unsigned char D.19949;
  int D.19952;
  <unnamed type> D.19955;
  unsigned int D.19956;
  int has_per_allocation_action.58;
  int iftmp.59;
  int D.19966;
  unsigned char D.19968;
  unsigned char D.19969;
  _Bool D.19970;
  long int D.19971;
  long int D.19972;
  int tlab_next_offset;
  int tlab_temp_end_offset;

  tlab_next_offset = -1;
  tlab_temp_end_offset = -1;
  {
    guint64 foo;

    __asm__("movq $tlab_next@TPOFF, %0" : "=r" foo);
    tlab_next_offset = (int) foo;
  }
  {
    guint64 foo;

    __asm__("movq $tlab_temp_end@TPOFF, %0" : "=r" foo);
    tlab_temp_end_offset = (int) foo;
  }
  D.19943 = tlab_next_offset == -1;
  D.19944 = tlab_temp_end_offset == -1;
  D.19945 = D.19943 | D.19944;
  if (D.19945 != 0) goto <D.19946>; else goto <D.19947>;
  <D.19946>:
  D.19948 = 0B;
  return D.19948;
  <D.19947>:
  D.19949 = klass->rank;
  if (D.19949 != 1) goto <D.19950>; else goto <D.19951>;
  <D.19950>:
  D.19948 = 0B;
  return D.19948;
  <D.19951>:
  D.19952 = mono_runtime_has_tls_get ();
  if (D.19952 == 0) goto <D.19953>; else goto <D.19954>;
  <D.19953>:
  D.19948 = 0B;
  return D.19948;
  <D.19954>:
  D.19955 = mono_profiler_get_events ();
  D.19956 = D.19955 & 128;
  if (D.19956 != 0) goto <D.19957>; else goto <D.19958>;
  <D.19957>:
  D.19948 = 0B;
  return D.19948;
  <D.19958>:
  has_per_allocation_action.58 = has_per_allocation_action;
  if (has_per_allocation_action.58 != 0) goto <D.19960>; else goto <D.19961>;
  <D.19960>:
  D.19948 = 0B;
  return D.19948;
  <D.19961>:
  D.19966 = mono_class_has_finalizer (klass);
  if (D.19966 != 0) goto <D.19963>; else goto <D.19967>;
  <D.19967>:
  D.19968 = BIT_FIELD_REF <*klass, 8, 272>;
  D.19969 = D.19968 & 64;
  if (D.19969 != 0) goto <D.19963>; else goto <D.19964>;
  <D.19963>:
  iftmp.59 = 1;
  goto <D.19965>;
  <D.19964>:
  iftmp.59 = 0;
  <D.19965>:
  D.19970 = iftmp.59 != 0;
  D.19971 = (long int) D.19970;
  D.19972 = __builtin_expect (D.19971, 0);
  if (D.19972 != 0) goto <D.19973>; else goto <D.19974>;
  <D.19973>:
  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.19974>:
  D.19948 = mono_gc_get_managed_allocator_by_type (1);
  return D.19948;
}


sgen_set_use_managed_allocator (gboolean flag)
{
  use_managed_allocator = flag;
}


mono_gc_get_managed_allocator_by_type (int atype)
{
  int use_managed_allocator.60;
  struct MonoMethod * D.19979;
  int D.19980;
  struct MonoMethod * D.19985;
  struct MonoMethod * res;

  use_managed_allocator.60 = use_managed_allocator;
  if (use_managed_allocator.60 == 0) goto <D.19977>; else goto <D.19978>;
  <D.19977>:
  D.19979 = 0B;
  return D.19979;
  <D.19978>:
  D.19980 = mono_runtime_has_tls_get ();
  if (D.19980 == 0) goto <D.19981>; else goto <D.19982>;
  <D.19981>:
  D.19979 = 0B;
  return D.19979;
  <D.19982>:
  res = alloc_method_cache[atype];
  if (res != 0B) goto <D.19983>; else goto <D.19984>;
  <D.19983>:
  D.19979 = res;
  return D.19979;
  <D.19984>:
  res = create_allocator (atype);
  pthread_mutex_lock (&gc_mutex);
  D.19985 = alloc_method_cache[atype];
  if (D.19985 != 0B) goto <D.19986>; else goto <D.19987>;
  <D.19986>:
  mono_free_method (res);
  res = alloc_method_cache[atype];
  goto <D.19988>;
  <D.19987>:
  mono_memory_barrier ();
  alloc_method_cache[atype] = res;
  <D.19988>:
  sgen_gc_unlock ();
  D.19979 = res;
  return D.19979;
}


create_allocator (int atype)
{
  _Bool D.19990;
  long int D.19991;
  long int D.19992;
  _Bool D.19995;
  long int D.19996;
  long int D.19997;
  int registered.61;
  struct MonoMethodSignature * D.20003;
  struct MonoMethodSignature * D.20004;
  struct MonoMethodSignature * D.20005;
  unsigned int num_params.62;
  struct MonoImage * D.20019;
  struct MonoClass * D.20022;
  struct MonoType * D.20023;
  struct MonoClass * D.20024;
  struct MonoType * D.20025;
  struct MonoClass * D.20026;
  struct MonoType * D.20027;
  struct MonoClass * D.20029;
  struct MonoType * D.20030;
  _Bool D.20031;
  _Bool D.20032;
  _Bool D.20033;
  unsigned int size_var.63;
  unsigned int D.20040;
  unsigned int pos.64;
  int D.20042;
  unsigned int D.20043;
  unsigned int D.20044;
  int D.20045;
  unsigned int D.20046;
  unsigned int D.20047;
  unsigned int D.20048;
  struct MonoClass * D.20049;
  struct MonoClass * D.20050;
  _Bool D.20051;
  long int D.20052;
  long int D.20053;
  int D.20056;
  unsigned int D.20057;
  _Bool D.20058;
  long int D.20059;
  long int D.20060;
  _Bool D.20063;
  long int D.20064;
  long int D.20065;
  int D.20068;
  unsigned int D.20069;
  unsigned int D.20070;
  unsigned int D.20071;
  unsigned int pos_leave.65;
  unsigned int tlab_next_addr_var.66;
  unsigned int p_var.67;
  unsigned int new_next_var.68;
  struct MonoMethodHeader * D.20098;
  struct MonoMethod * D.20099;
  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;
  {
    guint64 foo;

    __asm__("movq $tlab_next_addr@TPOFF, %0" : "=r" foo);
    tlab_next_addr_offset = (int) foo;
  }
  {
    guint64 foo;

    __asm__("movq $tlab_temp_end@TPOFF, %0" : "=r" foo);
    tlab_temp_end_offset = (int) foo;
  }
  mono_tls_key_set_offset (5, tlab_next_addr_offset);
  mono_tls_key_set_offset (6, tlab_temp_end_offset);
  D.19990 = tlab_next_addr_offset == -1;
  D.19991 = (long int) D.19990;
  D.19992 = __builtin_expect (D.19991, 0);
  if (D.19992 != 0) goto <D.19993>; else goto <D.19994>;
  <D.19993>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "sgen-alloc.c", 710, "tlab_next_addr_offset != -1");
  <D.19994>:
  D.19995 = tlab_temp_end_offset == -1;
  D.19996 = (long int) D.19995;
  D.19997 = __builtin_expect (D.19996, 0);
  if (D.19997 != 0) goto <D.19998>; else goto <D.19999>;
  <D.19998>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "sgen-alloc.c", 711, "tlab_temp_end_offset != -1");
  <D.19999>:
  registered.61 = registered;
  if (registered.61 == 0) goto <D.20001>; else goto <D.20002>;
  <D.20001>:
  D.20003 = mono_create_icall_signature ("object ptr int");
  mono_register_jit_icall (mono_gc_alloc_obj, "mono_gc_alloc_obj", D.20003, 0);
  D.20004 = mono_create_icall_signature ("object ptr int int");
  mono_register_jit_icall (mono_gc_alloc_vector, "mono_gc_alloc_vector", D.20004, 0);
  D.20005 = mono_create_icall_signature ("object ptr int int32");
  mono_register_jit_icall (mono_gc_alloc_string, "mono_gc_alloc_string", D.20005, 0);
  registered = 1;
  <D.20002>:
  if (atype == 2) goto <D.20006>; else goto <D.20007>;
  <D.20006>:
  num_params = 1;
  name = "AllocSmall";
  goto <D.20008>;
  <D.20007>:
  if (atype == 0) goto <D.20009>; else goto <D.20010>;
  <D.20009>:
  num_params = 1;
  name = "Alloc";
  goto <D.20011>;
  <D.20010>:
  if (atype == 1) goto <D.20012>; else goto <D.20013>;
  <D.20012>:
  num_params = 2;
  name = "AllocVector";
  goto <D.20014>;
  <D.20013>:
  if (atype == 3) goto <D.20015>; else goto <D.20016>;
  <D.20015>:
  num_params = 2;
  name = "AllocString";
  goto <D.20017>;
  <D.20016>:
  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "sgen-alloc.c", 734);
  <D.20017>:
  <D.20014>:
  <D.20011>:
  <D.20008>:
  num_params.62 = (unsigned int) num_params;
  D.20019 = mono_defaults.corlib;
  csig = mono_metadata_signature_alloc (D.20019, num_params.62);
  if (atype == 3) goto <D.20020>; else goto <D.20021>;
  <D.20020>:
  D.20022 = mono_defaults.string_class;
  D.20023 = &D.20022->byval_arg;
  csig->ret = D.20023;
  D.20024 = mono_defaults.int_class;
  D.20025 = &D.20024->byval_arg;
  csig->params[0] = D.20025;
  D.20026 = mono_defaults.int32_class;
  D.20027 = &D.20026->byval_arg;
  csig->params[1] = D.20027;
  goto <D.20028>;
  <D.20021>:
  D.20029 = mono_defaults.object_class;
  D.20030 = &D.20029->byval_arg;
  csig->ret = D.20030;
  i = 0;
  goto <D.19434>;
  <D.19433>:
  D.20024 = mono_defaults.int_class;
  D.20025 = &D.20024->byval_arg;
  csig->params[i] = D.20025;
  i = i + 1;
  <D.19434>:
  if (i < num_params) goto <D.19433>; else goto <D.19435>;
  <D.19435>:
  <D.20028>:
  D.20029 = mono_defaults.object_class;
  mb = mono_mb_new (D.20029, name, 28);
  D.20026 = mono_defaults.int32_class;
  D.20027 = &D.20026->byval_arg;
  size_var = mono_mb_add_local (mb, D.20027);
  D.20031 = atype == 0;
  D.20032 = atype == 2;
  D.20033 = D.20031 | D.20032;
  if (D.20033 != 0) goto <D.20034>; else goto <D.20035>;
  <D.20034>:
  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.63 = (unsigned int) size_var;
  mono_mb_emit_stloc (mb, size_var.63);
  goto <D.20037>;
  <D.20035>:
  if (atype == 1) goto <D.20038>; else goto <D.20039>;
  <D.20038>:
  {
    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.20040 = mono_mb_emit_short_branch (mb, 54);
    pos = (int) D.20040;
    mono_mb_emit_exception (mb, "OverflowException", 0B);
    pos.64 = (unsigned int) pos;
    mono_mb_patch_short_branch (mb, pos.64);
    D.20019 = mono_defaults.corlib;
    clause = mono_image_alloc0 (D.20019, 32);
    D.20042 = mono_mb_get_label (mb);
    D.20043 = (unsigned int) D.20042;
    clause->try_offset = D.20043;
    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.63 = (unsigned int) size_var;
    mono_mb_emit_stloc (mb, size_var.63);
    D.20044 = mono_mb_emit_branch (mb, 221);
    pos_leave = (int) D.20044;
    clause->flags = 0;
    D.20045 = mono_mb_get_pos (mb);
    D.20046 = (unsigned int) D.20045;
    D.20047 = clause->try_offset;
    D.20048 = D.20046 - D.20047;
    clause->try_len = D.20048;
    D.20019 = mono_defaults.corlib;
    D.20049 = mono_class_from_name (D.20019, "System", "OverflowException");
    clause->data.catch_class = D.20049;
    D.20050 = clause->data.catch_class;
    D.20051 = D.20050 == 0B;
    D.20052 = (long int) D.20051;
    D.20053 = __builtin_expect (D.20052, 0);
    if (D.20053 != 0) goto <D.20054>; else goto <D.20055>;
    <D.20054>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "sgen-alloc.c", 803, "clause->data.catch_class");
    <D.20055>:
    D.20056 = mono_mb_get_label (mb);
    D.20057 = (unsigned int) D.20056;
    clause->handler_offset = D.20057;
    D.20019 = mono_defaults.corlib;
    oom_exc_class = mono_class_from_name (D.20019, "System", "OutOfMemoryException");
    D.20058 = oom_exc_class == 0B;
    D.20059 = (long int) D.20058;
    D.20060 = __builtin_expect (D.20059, 0);
    if (D.20060 != 0) goto <D.20061>; else goto <D.20062>;
    <D.20061>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "sgen-alloc.c", 808, "oom_exc_class");
    <D.20062>:
    ctor = mono_class_get_method_from_name (oom_exc_class, ".ctor", 0);
    D.20063 = ctor == 0B;
    D.20064 = (long int) D.20063;
    D.20065 = __builtin_expect (D.20064, 0);
    if (D.20065 != 0) goto <D.20066>; else goto <D.20067>;
    <D.20066>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "sgen-alloc.c", 810, "ctor");
    <D.20067>:
    mono_mb_emit_byte (mb, 38);
    mono_mb_emit_op (mb, 115, ctor);
    mono_mb_emit_byte (mb, 122);
    D.20068 = mono_mb_get_pos (mb);
    D.20069 = (unsigned int) D.20068;
    D.20070 = clause->handler_offset;
    D.20071 = D.20069 - D.20070;
    clause->handler_len = D.20071;
    mono_mb_set_clauses (mb, 1, clause);
    pos_leave.65 = (unsigned int) pos_leave;
    mono_mb_patch_branch (mb, pos_leave.65);
  }
  goto <D.20073>;
  <D.20039>:
  if (atype == 3) goto <D.20074>; else goto <D.20075>;
  <D.20074>:
  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.63 = (unsigned int) size_var;
  mono_mb_emit_stloc (mb, size_var.63);
  goto <D.20076>;
  <D.20075>:
  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "sgen-alloc.c", 831);
  <D.20076>:
  <D.20073>:
  <D.20037>:
  size_var.63 = (unsigned int) size_var;
  mono_mb_emit_ldloc (mb, size_var.63);
  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.63 = (unsigned int) size_var;
  mono_mb_emit_stloc (mb, size_var.63);
  if (atype != 2) goto <D.20077>; else goto <D.20078>;
  <D.20077>:
  size_var.63 = (unsigned int) size_var;
  mono_mb_emit_ldloc (mb, size_var.63);
  mono_mb_emit_icon (mb, 8000);
  max_size_branch = mono_mb_emit_short_branch (mb, 53);
  <D.20078>:
  D.20024 = mono_defaults.int_class;
  D.20025 = &D.20024->byval_arg;
  tlab_next_addr_var = mono_mb_add_local (mb, D.20025);
  mono_mb_emit_byte (mb, 240);
  mono_mb_emit_byte (mb, 13);
  mono_mb_emit_i4 (mb, 5);
  tlab_next_addr_var.66 = (unsigned int) tlab_next_addr_var;
  mono_mb_emit_stloc (mb, tlab_next_addr_var.66);
  D.20024 = mono_defaults.int_class;
  D.20025 = &D.20024->byval_arg;
  p_var = mono_mb_add_local (mb, D.20025);
  tlab_next_addr_var.66 = (unsigned int) tlab_next_addr_var;
  mono_mb_emit_ldloc (mb, tlab_next_addr_var.66);
  mono_mb_emit_byte (mb, 77);
  p_var.67 = (unsigned int) p_var;
  mono_mb_emit_stloc (mb, p_var.67);
  D.20024 = mono_defaults.int_class;
  D.20025 = &D.20024->byval_arg;
  new_next_var = mono_mb_add_local (mb, D.20025);
  p_var.67 = (unsigned int) p_var;
  mono_mb_emit_ldloc (mb, p_var.67);
  size_var.63 = (unsigned int) size_var;
  mono_mb_emit_ldloc (mb, size_var.63);
  mono_mb_emit_byte (mb, 211);
  mono_mb_emit_byte (mb, 88);
  new_next_var.68 = (unsigned int) new_next_var;
  mono_mb_emit_stloc (mb, new_next_var.68);
  new_next_var.68 = (unsigned int) new_next_var;
  mono_mb_emit_ldloc (mb, new_next_var.68);
  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.20082>; else goto <D.20083>;
  <D.20082>:
  mono_mb_patch_short_branch (mb, max_size_branch);
  <D.20083>:
  mono_mb_emit_byte (mb, 240);
  mono_mb_emit_byte (mb, 12);
  mono_mb_emit_ldarg (mb, 0);
  size_var.63 = (unsigned int) size_var;
  mono_mb_emit_ldloc (mb, size_var.63);
  D.20031 = atype == 0;
  D.20032 = atype == 2;
  D.20033 = D.20031 | D.20032;
  if (D.20033 != 0) goto <D.20084>; else goto <D.20085>;
  <D.20084>:
  mono_mb_emit_icall (mb, mono_gc_alloc_obj);
  goto <D.20086>;
  <D.20085>:
  if (atype == 1) goto <D.20087>; else goto <D.20088>;
  <D.20087>:
  mono_mb_emit_ldarg (mb, 1);
  mono_mb_emit_icall (mb, mono_gc_alloc_vector);
  goto <D.20089>;
  <D.20088>:
  if (atype == 3) goto <D.20090>; else goto <D.20091>;
  <D.20090>:
  mono_mb_emit_ldarg (mb, 1);
  mono_mb_emit_icall (mb, mono_gc_alloc_string);
  goto <D.20092>;
  <D.20091>:
  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "sgen-alloc.c", 898);
  <D.20092>:
  <D.20089>:
  <D.20086>:
  mono_mb_emit_byte (mb, 42);
  mono_mb_patch_short_branch (mb, slowpath_branch);
  tlab_next_addr_var.66 = (unsigned int) tlab_next_addr_var;
  mono_mb_emit_ldloc (mb, tlab_next_addr_var.66);
  new_next_var.68 = (unsigned int) new_next_var;
  mono_mb_emit_ldloc (mb, new_next_var.68);
  mono_mb_emit_byte (mb, 223);
  mono_mb_emit_byte (mb, 240);
  mono_mb_emit_op (mb, 16, 0B);
  p_var.67 = (unsigned int) p_var;
  mono_mb_emit_ldloc (mb, p_var.67);
  mono_mb_emit_ldarg (mb, 0);
  mono_mb_emit_byte (mb, 223);
  if (atype == 1) goto <D.20093>; else goto <D.20094>;
  <D.20093>:
  p_var.67 = (unsigned int) p_var;
  mono_mb_emit_ldloc (mb, p_var.67);
  mono_mb_emit_ldflda (mb, 24);
  mono_mb_emit_ldarg (mb, 1);
  mono_mb_emit_byte (mb, 84);
  goto <D.20095>;
  <D.20094>:
  if (atype == 3) goto <D.20096>; else goto <D.20097>;
  <D.20096>:
  p_var.67 = (unsigned int) p_var;
  mono_mb_emit_ldloc (mb, p_var.67);
  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.67 = (unsigned int) p_var;
  mono_mb_emit_ldloc (mb, p_var.67);
  size_var.63 = (unsigned int) size_var;
  mono_mb_emit_ldloc (mb, size_var.63);
  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.20097>:
  <D.20095>:
  mono_mb_emit_byte (mb, 240);
  mono_mb_emit_op (mb, 16, 0B);
  p_var.67 = (unsigned int) p_var;
  mono_mb_emit_ldloc (mb, p_var.67);
  mono_mb_emit_byte (mb, 42);
  res = mono_mb_create_method (mb, csig, 8);
  mono_mb_free (mb);
  D.20098 = mono_method_get_header (res);
  D.20098->init_locals = 0;
  D.20019 = mono_defaults.corlib;
  info = mono_image_alloc0 (D.20019, 16);
  info->gc_name = "sgen";
  info->alloc_type = atype;
  mono_marshal_set_wrapper_info (res, info);
  D.20099 = res;
  return D.20099;
}


mono_gc_get_managed_allocator_types ()
{
  guint32 D.20101;

  D.20101 = 4;
  return D.20101;
}


sgen_is_managed_allocator (struct MonoMethod * method)
{
  struct MonoMethod * D.20103;
  gboolean D.20106;
  int i;

  i = 0;
  goto <D.19471>;
  <D.19470>:
  D.20103 = alloc_method_cache[i];
  if (D.20103 == method) goto <D.20104>; else goto <D.20105>;
  <D.20104>:
  D.20106 = 1;
  return D.20106;
  <D.20105>:
  i = i + 1;
  <D.19471>:
  if (i <= 3) goto <D.19470>; else goto <D.19472>;
  <D.19472>:
  D.20106 = 0;
  return D.20106;
}


sgen_has_managed_allocator ()
{
  struct MonoMethod * D.20108;
  gboolean D.20111;
  int i;

  i = 0;
  goto <D.19478>;
  <D.19477>:
  D.20108 = alloc_method_cache[i];
  if (D.20108 != 0B) goto <D.20109>; else goto <D.20110>;
  <D.20109>:
  D.20111 = 1;
  return D.20111;
  <D.20110>:
  i = i + 1;
  <D.19478>:
  if (i <= 3) goto <D.19477>; else goto <D.19479>;
  <D.19479>:
  D.20111 = 0;
  return D.20111;
}