sgen_need_major_collection (mword space_needed)
{
  int D.17498;
  gboolean D.17501;
  unsigned int los_memory_usage.0;
  unsigned int last_collection_los_memory_usage.1;
  unsigned int D.17504;
  int iftmp.2;
  unsigned int D.17509;
  unsigned int D.17511;
  int minor_collection_sections_alloced.3;
  unsigned int minor_collection_sections_alloced.4;
  unsigned int D.17514;
  unsigned int D.17515;
  unsigned int minor_collection_allowance.5;
  mword los_alloced;

  D.17498 = sgen_concurrent_collection_in_progress ();
  if (D.17498 != 0) goto <D.17499>; else goto <D.17500>;
  <D.17499>:
  D.17501 = 0;
  return D.17501;
  <D.17500>:
  los_memory_usage.0 = los_memory_usage;
  los_memory_usage.0 = los_memory_usage;
  last_collection_los_memory_usage.1 = last_collection_los_memory_usage;
  D.17504 = MIN_EXPR <los_memory_usage.0, last_collection_los_memory_usage.1>;
  los_alloced = los_memory_usage.0 - D.17504;
  D.17509 = sgen_memgov_available_free_space ();
  if (D.17509 < space_needed) goto <D.17506>; else goto <D.17510>;
  <D.17510>:
  D.17511 = major_collector.section_size;
  minor_collection_sections_alloced.3 = minor_collection_sections_alloced;
  minor_collection_sections_alloced.4 = (unsigned int) minor_collection_sections_alloced.3;
  D.17514 = D.17511 * minor_collection_sections_alloced.4;
  D.17515 = D.17514 + los_alloced;
  minor_collection_allowance.5 = minor_collection_allowance;
  if (D.17515 > minor_collection_allowance.5) goto <D.17506>; else goto <D.17507>;
  <D.17506>:
  iftmp.2 = 1;
  goto <D.17508>;
  <D.17507>:
  iftmp.2 = 0;
  <D.17508>:
  D.17501 = iftmp.2;
  return D.17501;
}


sgen_memgov_available_free_space ()
{
  mword D.17518;
  unsigned int max_heap_size.6;
  unsigned int allocated_heap.7;
  unsigned int D.17521;

  max_heap_size.6 = max_heap_size;
  max_heap_size.6 = max_heap_size;
  allocated_heap.7 = allocated_heap;
  D.17521 = MIN_EXPR <max_heap_size.6, allocated_heap.7>;
  D.17518 = max_heap_size.6 - D.17521;
  return D.17518;
}


sgen_memgov_minor_collection_start ()
{
  sgen_memgov_try_calculate_minor_collection_allowance (0);
}


sgen_memgov_try_calculate_minor_collection_allowance (gboolean overwrite)
{
  int need_calculate_minor_collection_allowance.8;
  _Bool D.17526;
  long int D.17527;
  long int D.17528;
  gboolean * D.17533;
  int D.17534;
  int sgen_nursery_size.9;
  double D.17540;
  double default_allowance_nursery_size_ratio.10;
  double D.17542;
  unsigned int minor_collection_allowance.11;
  int (*<T980>) (void) D.17544;
  int last_collection_old_num_major_sections.12;
  int D.17546;
  unsigned int last_collection_old_los_memory_usage.13;
  unsigned int last_collection_los_memory_usage.14;
  unsigned int D.17549;
  unsigned int D.17550;
  unsigned int num_major_sections.15;
  unsigned int D.17552;
  double D.17553;
  double D.17554;
  double D.17555;
  int minor_collection_sections_alloced.16;
  unsigned int minor_collection_sections_alloced.17;
  unsigned int D.17558;
  unsigned int last_collection_los_memory_alloced.18;
  unsigned int D.17560;
  double D.17561;
  double D.17562;
  unsigned int num_major_sections_saved.19;
  unsigned int D.17564;
  unsigned int D.17565;
  double D.17566;
  double D.17567;
  unsigned int D.17568;
  unsigned int los_memory_usage.20;
  unsigned int D.17570;
  unsigned int D.17571;
  unsigned int minor_collection_allowance.21;
  unsigned int minor_collection_allowance.22;
  unsigned int D.17574;
  unsigned int soft_heap_limit.23;
  unsigned int D.17581;
  unsigned int minor_collection_allowance.24;
  int debug_print_allowance.25;
  unsigned int last_collection_old_num_major_sections.26;
  int gc_debug_level.27;
  _Bool D.17588;
  long int D.17589;
  long int D.17590;
  long int last_collection_old_los_memory_usage.28;
  long int old_major.29;
  unsigned int D.17595;
  long int D.17596;
  struct FILE * gc_debug_file.30;
  long int last_collection_los_memory_usage.31;
  long int new_major.32;
  long int new_heap_size.33;
  long int minor_collection_allowance.34;
  void (*<T47b>) (void) D.17606;
  int num_major_sections;
  int num_major_sections_saved;
  mword los_memory_saved;
  mword new_major;
  mword new_heap_size;
  mword save_target;
  mword allowance_target;

  if (overwrite != 0) goto <D.17523>; else goto <D.17524>;
  <D.17523>:
  need_calculate_minor_collection_allowance.8 = need_calculate_minor_collection_allowance;
  D.17526 = need_calculate_minor_collection_allowance.8 == 0;
  D.17527 = (long int) D.17526;
  D.17528 = __builtin_expect (D.17527, 0);
  if (D.17528 != 0) goto <D.17529>; else goto <D.17530>;
  <D.17529>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "sgen-memory-governor.c", 92, "need_calculate_minor_collection_allowance");
  <D.17530>:
  <D.17524>:
  need_calculate_minor_collection_allowance.8 = need_calculate_minor_collection_allowance;
  if (need_calculate_minor_collection_allowance.8 == 0) goto <D.17531>; else goto <D.17532>;
  <D.17531>:
  return;
  <D.17532>:
  D.17533 = major_collector.have_swept;
  D.17534 = *D.17533;
  if (D.17534 == 0) goto <D.17535>; else goto <D.17536>;
  <D.17535>:
  if (overwrite != 0) goto <D.17537>; else goto <D.17538>;
  <D.17537>:
  sgen_nursery_size.9 = sgen_nursery_size;
  D.17540 = (double) sgen_nursery_size.9;
  default_allowance_nursery_size_ratio.10 = default_allowance_nursery_size_ratio;
  D.17542 = D.17540 * default_allowance_nursery_size_ratio.10;
  minor_collection_allowance.11 = (unsigned int) D.17542;
  minor_collection_allowance = minor_collection_allowance.11;
  <D.17538>:
  return;
  <D.17536>:
  D.17544 = major_collector.get_num_major_sections;
  num_major_sections = D.17544 ();
  last_collection_old_num_major_sections.12 = last_collection_old_num_major_sections;
  D.17546 = last_collection_old_num_major_sections.12 - num_major_sections;
  num_major_sections_saved = MAX_EXPR <D.17546, 0>;
  last_collection_old_los_memory_usage.13 = last_collection_old_los_memory_usage;
  last_collection_los_memory_usage.14 = last_collection_los_memory_usage;
  D.17549 = last_collection_old_los_memory_usage.13 - last_collection_los_memory_usage.14;
  los_memory_saved = MAX_EXPR <D.17549, 1>;
  D.17550 = major_collector.section_size;
  num_major_sections.15 = (unsigned int) num_major_sections;
  new_major = D.17550 * num_major_sections.15;
  last_collection_los_memory_usage.14 = last_collection_los_memory_usage;
  new_heap_size = new_major + last_collection_los_memory_usage.14;
  last_collection_los_memory_usage.14 = last_collection_los_memory_usage;
  D.17552 = new_major + last_collection_los_memory_usage.14;
  D.17553 = (double) D.17552;
  D.17554 = D.17553 * 5.0e-1;
  save_target = (mword) D.17554;
  D.17555 = (double) save_target;
  D.17550 = major_collector.section_size;
  minor_collection_sections_alloced.16 = minor_collection_sections_alloced;
  minor_collection_sections_alloced.17 = (unsigned int) minor_collection_sections_alloced.16;
  D.17558 = D.17550 * minor_collection_sections_alloced.17;
  last_collection_los_memory_alloced.18 = last_collection_los_memory_alloced;
  D.17560 = D.17558 + last_collection_los_memory_alloced.18;
  D.17561 = (double) D.17560;
  D.17562 = D.17555 * D.17561;
  D.17550 = major_collector.section_size;
  num_major_sections_saved.19 = (unsigned int) num_major_sections_saved;
  D.17564 = D.17550 * num_major_sections_saved.19;
  D.17565 = D.17564 + los_memory_saved;
  D.17566 = (double) D.17565;
  D.17567 = D.17562 / D.17566;
  allowance_target = double_to_mword_with_saturation (D.17567);
  sgen_nursery_size.9 = sgen_nursery_size;
  D.17540 = (double) sgen_nursery_size.9;
  default_allowance_nursery_size_ratio.10 = default_allowance_nursery_size_ratio;
  D.17542 = D.17540 * default_allowance_nursery_size_ratio.10;
  minor_collection_allowance.11 = (unsigned int) D.17542;
  D.17550 = major_collector.section_size;
  num_major_sections.15 = (unsigned int) num_major_sections;
  D.17568 = D.17550 * num_major_sections.15;
  los_memory_usage.20 = los_memory_usage;
  D.17570 = D.17568 + los_memory_usage.20;
  D.17571 = MIN_EXPR <D.17570, allowance_target>;
  minor_collection_allowance.21 = MAX_EXPR <minor_collection_allowance.11, D.17571>;
  minor_collection_allowance = minor_collection_allowance.21;
  minor_collection_allowance.22 = minor_collection_allowance;
  D.17574 = new_heap_size + minor_collection_allowance.22;
  soft_heap_limit.23 = soft_heap_limit;
  if (D.17574 > soft_heap_limit.23) goto <D.17576>; else goto <D.17577>;
  <D.17576>:
  soft_heap_limit.23 = soft_heap_limit;
  if (new_heap_size > soft_heap_limit.23) goto <D.17578>; else goto <D.17579>;
  <D.17578>:
  sgen_nursery_size.9 = sgen_nursery_size;
  D.17540 = (double) sgen_nursery_size.9;
  default_allowance_nursery_size_ratio.10 = default_allowance_nursery_size_ratio;
  D.17542 = D.17540 * default_allowance_nursery_size_ratio.10;
  minor_collection_allowance.11 = (unsigned int) D.17542;
  minor_collection_allowance = minor_collection_allowance.11;
  goto <D.17580>;
  <D.17579>:
  sgen_nursery_size.9 = sgen_nursery_size;
  D.17540 = (double) sgen_nursery_size.9;
  default_allowance_nursery_size_ratio.10 = default_allowance_nursery_size_ratio;
  D.17542 = D.17540 * default_allowance_nursery_size_ratio.10;
  minor_collection_allowance.11 = (unsigned int) D.17542;
  soft_heap_limit.23 = soft_heap_limit;
  D.17581 = soft_heap_limit.23 - new_heap_size;
  minor_collection_allowance.24 = MAX_EXPR <minor_collection_allowance.11, D.17581>;
  minor_collection_allowance = minor_collection_allowance.24;
  <D.17580>:
  <D.17577>:
  debug_print_allowance.25 = debug_print_allowance;
  if (debug_print_allowance.25 != 0) goto <D.17584>; else goto <D.17585>;
  <D.17584>:
  {
    mword old_major;

    D.17550 = major_collector.section_size;
    last_collection_old_num_major_sections.12 = last_collection_old_num_major_sections;
    last_collection_old_num_major_sections.26 = (unsigned int) last_collection_old_num_major_sections.12;
    old_major = D.17550 * last_collection_old_num_major_sections.26;
    gc_debug_level.27 = gc_debug_level;
    D.17588 = gc_debug_level.27 > 0;
    D.17589 = (long int) D.17588;
    D.17590 = __builtin_expect (D.17589, 0);
    if (D.17590 != 0) goto <D.17591>; else goto <D.17592>;
    <D.17591>:
    last_collection_old_los_memory_usage.13 = last_collection_old_los_memory_usage;
    last_collection_old_los_memory_usage.28 = (long int) last_collection_old_los_memory_usage.13;
    old_major.29 = (long int) old_major;
    last_collection_old_los_memory_usage.13 = last_collection_old_los_memory_usage;
    D.17595 = old_major + last_collection_old_los_memory_usage.13;
    D.17596 = (long int) D.17595;
    gc_debug_file.30 = gc_debug_file;
    fprintf (gc_debug_file.30, "Before collection: %ld bytes (%ld major, %ld LOS)\n", D.17596, old_major.29, last_collection_old_los_memory_usage.28);
    gc_debug_file.30 = gc_debug_file;
    fflush (gc_debug_file.30);
    <D.17592>:
    gc_debug_level.27 = gc_debug_level;
    D.17588 = gc_debug_level.27 > 0;
    D.17589 = (long int) D.17588;
    D.17590 = __builtin_expect (D.17589, 0);
    if (D.17590 != 0) goto <D.17598>; else goto <D.17599>;
    <D.17598>:
    last_collection_los_memory_usage.14 = last_collection_los_memory_usage;
    last_collection_los_memory_usage.31 = (long int) last_collection_los_memory_usage.14;
    new_major.32 = (long int) new_major;
    new_heap_size.33 = (long int) new_heap_size;
    gc_debug_file.30 = gc_debug_file;
    fprintf (gc_debug_file.30, "After collection: %ld bytes (%ld major, %ld LOS)\n", new_heap_size.33, new_major.32, last_collection_los_memory_usage.31);
    gc_debug_file.30 = gc_debug_file;
    fflush (gc_debug_file.30);
    <D.17599>:
    gc_debug_level.27 = gc_debug_level;
    D.17588 = gc_debug_level.27 > 0;
    D.17589 = (long int) D.17588;
    D.17590 = __builtin_expect (D.17589, 0);
    if (D.17590 != 0) goto <D.17603>; else goto <D.17604>;
    <D.17603>:
    minor_collection_allowance.22 = minor_collection_allowance;
    minor_collection_allowance.34 = (long int) minor_collection_allowance.22;
    gc_debug_file.30 = gc_debug_file;
    fprintf (gc_debug_file.30, "Allowance: %ld bytes\n", minor_collection_allowance.34);
    gc_debug_file.30 = gc_debug_file;
    fflush (gc_debug_file.30);
    <D.17604>:
  }
  <D.17585>:
  D.17606 = major_collector.have_computed_minor_collection_allowance;
  if (D.17606 != 0B) goto <D.17607>; else goto <D.17608>;
  <D.17607>:
  D.17606 = major_collector.have_computed_minor_collection_allowance;
  D.17606 ();
  <D.17608>:
  need_calculate_minor_collection_allowance = 0;
}


double_to_mword_with_saturation (double value)
{
  mword D.17612;

  if (value >= 4.294967295e+9) goto <D.17610>; else goto <D.17611>;
  <D.17610>:
  D.17612 = 4294967295;
  return D.17612;
  <D.17611>:
  D.17612 = (mword) value;
  return D.17612;
}


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

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


sgen_memgov_minor_collection_end ()
{

}


sgen_memgov_major_collection_start ()
{
  struct SgenMajorCollector * D.17616;
  int (*<T980>) (void) D.17617;
  int last_collection_old_num_major_sections.35;
  unsigned int los_memory_usage.36;
  unsigned int last_collection_los_memory_usage.37;
  unsigned int D.17621;
  unsigned int last_collection_los_memory_alloced.38;

  D.17616 = sgen_get_major_collector ();
  D.17617 = D.17616->get_num_major_sections;
  last_collection_old_num_major_sections.35 = D.17617 ();
  last_collection_old_num_major_sections = last_collection_old_num_major_sections.35;
  los_memory_usage.36 = los_memory_usage;
  los_memory_usage.36 = los_memory_usage;
  last_collection_los_memory_usage.37 = last_collection_los_memory_usage;
  D.17621 = MIN_EXPR <los_memory_usage.36, last_collection_los_memory_usage.37>;
  last_collection_los_memory_alloced.38 = los_memory_usage.36 - D.17621;
  last_collection_los_memory_alloced = last_collection_los_memory_alloced.38;
  los_memory_usage.36 = los_memory_usage;
  last_collection_old_los_memory_usage = los_memory_usage.36;
  need_calculate_minor_collection_allowance = 1;
}


sgen_memgov_major_collection_end ()
{
  unsigned int los_memory_usage.39;

  sgen_memgov_try_calculate_minor_collection_allowance (1);
  minor_collection_sections_alloced = 0;
  los_memory_usage.39 = los_memory_usage;
  last_collection_los_memory_usage = los_memory_usage.39;
}


sgen_memgov_collection_start (int generation)
{
  int (*<T980>) (void) D.17624;
  int last_major_num_sections.40;
  unsigned int los_memory_usage.41;
  int los_memory_usage.42;

  D.17624 = major_collector.get_num_major_sections;
  last_major_num_sections.40 = D.17624 ();
  last_major_num_sections = last_major_num_sections.40;
  los_memory_usage.41 = los_memory_usage;
  los_memory_usage.42 = (int) los_memory_usage.41;
  last_los_memory_usage = los_memory_usage.42;
}


sgen_memgov_collection_end (int generation, struct GGTimingInfo * info, int info_count)
{
  unsigned int i.43;
  unsigned int D.17629;
  struct GGTimingInfo * D.17630;
  int D.17631;
  int i;

  i = 0;
  goto <D.17423>;
  <D.17422>:
  i.43 = (unsigned int) i;
  D.17629 = i.43 * 36;
  D.17630 = info + D.17629;
  D.17631 = D.17630->generation;
  if (D.17631 != -1) goto <D.17632>; else goto <D.17633>;
  <D.17632>:
  i.43 = (unsigned int) i;
  D.17629 = i.43 * 36;
  D.17630 = info + D.17629;
  log_timming (D.17630);
  <D.17633>:
  i = i + 1;
  <D.17423>:
  if (i < info_count) goto <D.17422>; else goto <D.17424>;
  <D.17424>:
}


log_timming (struct GGTimingInfo * info)
{
  int (*<T980>) (void) D.17634;
  int D.17635;
  long long int D.17638;
  int D.17639;
  float D.17640;
  float D.17641;
  double D.17642;
  long long int D.17643;
  float D.17644;
  float D.17645;
  double D.17646;
  int D.17647;
  int last_los_memory_usage.44;
  int D.17651;
  unsigned int los_memory_usage.45;
  unsigned int D.17653;
  unsigned int D.17654;
  int last_major_num_sections.46;
  unsigned int last_major_num_sections.47;
  unsigned int D.17657;
  unsigned int D.17658;
  unsigned int num_major_sections.48;
  unsigned int D.17660;
  unsigned int D.17661;
  long long int D.17662;
  int D.17663;
  float D.17664;
  float D.17665;
  double D.17666;
  const char * iftmp.49;
  const char * D.17668;
  const char * iftmp.50;
  int D.17677;
  unsigned int D.17678;
  unsigned int D.17679;
  unsigned int D.17680;
  const char * iftmp.51;
  const char * iftmp.52;
  int num_major_sections;
  char full_timing_buff[1024];

  try
    {
      D.17634 = major_collector.get_num_major_sections;
      num_major_sections = D.17634 ();
      full_timing_buff[0] = 0;
      D.17635 = info->is_overflow;
      if (D.17635 == 0) goto <D.17636>; else goto <D.17637>;
      <D.17636>:
      D.17638 = info->bridge_time;
      D.17639 = (int) D.17638;
      D.17640 = (float) D.17639;
      D.17641 = D.17640 / 1.0e+3;
      D.17642 = (double) D.17641;
      D.17643 = info->stw_time;
      D.17644 = (float) D.17643;
      D.17645 = D.17644 / 1.0e+3;
      D.17646 = (double) D.17645;
      sprintf (&full_timing_buff, "total %.2fms, bridge %.2fms", D.17646, D.17642);
      <D.17637>:
      D.17647 = info->generation;
      if (D.17647 == 1) goto <D.17648>; else goto <D.17649>;
      <D.17648>:
      last_los_memory_usage.44 = last_los_memory_usage;
      D.17651 = last_los_memory_usage.44 / 1024;
      los_memory_usage.45 = los_memory_usage;
      D.17653 = los_memory_usage.45 / 1024;
      D.17654 = major_collector.section_size;
      last_major_num_sections.46 = last_major_num_sections;
      last_major_num_sections.47 = (unsigned int) last_major_num_sections.46;
      D.17657 = D.17654 * last_major_num_sections.47;
      D.17658 = D.17657 / 1024;
      D.17654 = major_collector.section_size;
      num_major_sections.48 = (unsigned int) num_major_sections;
      D.17660 = D.17654 * num_major_sections.48;
      D.17661 = D.17660 / 1024;
      D.17662 = info->total_time;
      D.17663 = (int) D.17662;
      D.17664 = (float) D.17663;
      D.17665 = D.17664 / 1.0e+3;
      D.17666 = (double) D.17665;
      D.17668 = info->reason;
      if (D.17668 != 0B) goto <D.17669>; else goto <D.17670>;
      <D.17669>:
      iftmp.49 = info->reason;
      goto <D.17671>;
      <D.17670>:
      iftmp.49 = "";
      <D.17671>:
      D.17635 = info->is_overflow;
      if (D.17635 != 0) goto <D.17673>; else goto <D.17674>;
      <D.17673>:
      iftmp.50 = "_OVERFLOW";
      goto <D.17675>;
      <D.17674>:
      iftmp.50 = "";
      <D.17675>:
      mono_trace (64, 8, "GC_MAJOR%s: (%s) pause %.2fms, %s major %dK/%dK los %dK/%dK", iftmp.50, iftmp.49, D.17666, &full_timing_buff, D.17661, D.17658, D.17653, D.17651);
      goto <D.17676>;
      <D.17649>:
      los_memory_usage.45 = los_memory_usage;
      D.17653 = los_memory_usage.45 / 1024;
      D.17654 = major_collector.section_size;
      num_major_sections.48 = (unsigned int) num_major_sections;
      D.17660 = D.17654 * num_major_sections.48;
      D.17661 = D.17660 / 1024;
      last_major_num_sections.46 = last_major_num_sections;
      D.17677 = num_major_sections - last_major_num_sections.46;
      D.17678 = (unsigned int) D.17677;
      D.17654 = major_collector.section_size;
      D.17679 = D.17678 * D.17654;
      D.17680 = D.17679 / 1024;
      D.17662 = info->total_time;
      D.17663 = (int) D.17662;
      D.17664 = (float) D.17663;
      D.17665 = D.17664 / 1.0e+3;
      D.17666 = (double) D.17665;
      D.17668 = info->reason;
      if (D.17668 != 0B) goto <D.17682>; else goto <D.17683>;
      <D.17682>:
      iftmp.51 = info->reason;
      goto <D.17684>;
      <D.17683>:
      iftmp.51 = "";
      <D.17684>:
      D.17635 = info->is_overflow;
      if (D.17635 != 0) goto <D.17686>; else goto <D.17687>;
      <D.17686>:
      iftmp.52 = "_OVERFLOW";
      goto <D.17688>;
      <D.17687>:
      iftmp.52 = "";
      <D.17688>:
      mono_trace (64, 8, "GC_MINOR%s: (%s) pause %.2fms, %s promoted %dK major %dK los %dK", iftmp.52, iftmp.51, D.17666, &full_timing_buff, D.17680, D.17661, D.17653);
      <D.17676>:
    }
  finally
    {
      full_timing_buff = {CLOBBER};
    }
}


sprintf (char * restrict __s, const char * restrict __fmt)
{
  int D.17689;
  unsigned int D.17690;

  D.17690 = __builtin_object_size (__s, 1);
  D.17689 = __builtin___sprintf_chk (__s, 1, D.17690, __fmt, __builtin_va_arg_pack ());
  return D.17689;
}


sgen_register_major_sections_alloced (int num_sections)
{
  int minor_collection_sections_alloced.53;
  int minor_collection_sections_alloced.54;

  minor_collection_sections_alloced.53 = minor_collection_sections_alloced;
  minor_collection_sections_alloced.54 = minor_collection_sections_alloced.53 + num_sections;
  minor_collection_sections_alloced = minor_collection_sections_alloced.54;
}


sgen_get_minor_collection_allowance ()
{
  mword D.17694;

  D.17694 = minor_collection_allowance;
  return D.17694;
}


mono_gc_add_memory_pressure (gint64 value)
{
  unsigned int D.17696;
  unsigned int memory_pressure.55;
  unsigned int memory_pressure.56;

  pthread_mutex_lock (&gc_mutex);
  D.17696 = (unsigned int) value;
  memory_pressure.55 = memory_pressure;
  memory_pressure.56 = D.17696 + memory_pressure.55;
  memory_pressure = memory_pressure.56;
  sgen_gc_unlock ();
}


sgen_assert_memory_alloc (void * ptr, size_t requested_size, const char * assert_description)
{
  _Bool D.17699;
  _Bool D.17700;
  _Bool D.17701;
  struct _IO_FILE * stderr.57;

  D.17699 = ptr != 0B;
  D.17700 = assert_description == 0B;
  D.17701 = D.17699 | D.17700;
  if (D.17701 != 0) goto <D.17702>; else goto <D.17703>;
  <D.17702>:
  return;
  <D.17703>:
  stderr.57 = stderr;
  fprintf (stderr.57, "Error: Garbage collector could not allocate %zu bytes of memory for %s.\n", requested_size, assert_description);
  exit (1);
}


sgen_alloc_os_memory (size_t size, SgenAllocFlags flags, const char * assert_description)
{
  unsigned int D.17706;
  _Bool D.17707;
  long int D.17708;
  long int D.17709;
  int flags.58;
  int D.17713;
  long unsigned int D.17714;
  int D.17715;
  void * __old_x.59;
  unsigned int D.17719;
  void * D.17720;
  void * D.17721;
  unsigned int D.17722;
  void * D.17725;
  void * ptr;

  D.17706 = flags & 4294967292;
  D.17707 = D.17706 != 0;
  D.17708 = (long int) D.17707;
  D.17709 = __builtin_expect (D.17708, 0);
  if (D.17709 != 0) goto <D.17710>; else goto <D.17711>;
  <D.17710>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "sgen-memory-governor.c", 306, "!(flags & ~(SGEN_ALLOC_HEAP | SGEN_ALLOC_ACTIVATE))");
  <D.17711>:
  flags.58 = (int) flags;
  D.17713 = flags.58 & 2;
  D.17714 = prot_flags_for_activate (D.17713);
  D.17715 = (int) D.17714;
  ptr = mono_valloc (0B, size, D.17715);
  sgen_assert_memory_alloc (ptr, size, assert_description);
  if (ptr != 0B) goto <D.17716>; else goto <D.17717>;
  <D.17716>:
  {
    size_t __old_x;

    <D.17450>:
    __old_x = total_alloc;
    __old_x.59 = (void *) __old_x;
    D.17719 = __old_x + size;
    D.17720 = (void *) D.17719;
    D.17721 = InterlockedCompareExchangePointer (&total_alloc, D.17720, __old_x.59);
    __old_x.59 = (void *) __old_x;
    if (D.17721 != __old_x.59) goto <D.17450>; else goto <D.17451>;
    <D.17451>:
  }
  D.17722 = flags & 1;
  if (D.17722 != 0) goto <D.17723>; else goto <D.17724>;
  <D.17723>:
  <D.17724>:
  <D.17717>:
  D.17725 = ptr;
  return D.17725;
}


prot_flags_for_activate (int activate)
{
  long unsigned int iftmp.60;
  long unsigned int D.17731;
  long unsigned int prot_flags;

  if (activate != 0) goto <D.17728>; else goto <D.17729>;
  <D.17728>:
  iftmp.60 = 3;
  goto <D.17730>;
  <D.17729>:
  iftmp.60 = 0;
  <D.17730>:
  prot_flags = iftmp.60;
  D.17731 = prot_flags | 80;
  return D.17731;
}


InterlockedCompareExchangePointer (void * volatile * dest, void * exch, void * comp)
{
  void * D.17733;
  unsigned int exch.61;
  unsigned int comp.62;
  unsigned int D.17736;

  exch.61 = (unsigned int) exch;
  comp.62 = (unsigned int) comp;
  D.17736 = __sync_val_compare_and_swap_4 (dest, comp.62, exch.61);
  D.17733 = (void *) D.17736;
  return D.17733;
}


sgen_alloc_os_memory_aligned (size_t size, mword alignment, SgenAllocFlags flags, const char * assert_description)
{
  unsigned int D.17738;
  _Bool D.17739;
  long int D.17740;
  long int D.17741;
  int flags.63;
  int D.17745;
  long unsigned int D.17746;
  int D.17747;
  void * __old_x.64;
  unsigned int D.17751;
  void * D.17752;
  void * D.17753;
  unsigned int D.17754;
  void * D.17757;
  void * ptr;

  D.17738 = flags & 4294967292;
  D.17739 = D.17738 != 0;
  D.17740 = (long int) D.17739;
  D.17741 = __builtin_expect (D.17740, 0);
  if (D.17741 != 0) goto <D.17742>; else goto <D.17743>;
  <D.17742>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "sgen-memory-governor.c", 324, "!(flags & ~(SGEN_ALLOC_HEAP | SGEN_ALLOC_ACTIVATE))");
  <D.17743>:
  flags.63 = (int) flags;
  D.17745 = flags.63 & 2;
  D.17746 = prot_flags_for_activate (D.17745);
  D.17747 = (int) D.17746;
  ptr = mono_valloc_aligned (size, alignment, D.17747);
  sgen_assert_memory_alloc (ptr, size, assert_description);
  if (ptr != 0B) goto <D.17748>; else goto <D.17749>;
  <D.17748>:
  {
    size_t __old_x;

    <D.17460>:
    __old_x = total_alloc;
    __old_x.64 = (void *) __old_x;
    D.17751 = __old_x + size;
    D.17752 = (void *) D.17751;
    D.17753 = InterlockedCompareExchangePointer (&total_alloc, D.17752, __old_x.64);
    __old_x.64 = (void *) __old_x;
    if (D.17753 != __old_x.64) goto <D.17460>; else goto <D.17461>;
    <D.17461>:
  }
  D.17754 = flags & 1;
  if (D.17754 != 0) goto <D.17755>; else goto <D.17756>;
  <D.17755>:
  <D.17756>:
  <D.17749>:
  D.17757 = ptr;
  return D.17757;
}


sgen_free_os_memory (void * addr, size_t size, SgenAllocFlags flags)
{
  unsigned int D.17759;
  _Bool D.17760;
  long int D.17761;
  long int D.17762;
  void * __old_x.65;
  unsigned int D.17766;
  void * D.17767;
  void * D.17768;
  unsigned int D.17769;

  D.17759 = flags & 4294967294;
  D.17760 = D.17759 != 0;
  D.17761 = (long int) D.17760;
  D.17762 = __builtin_expect (D.17761, 0);
  if (D.17762 != 0) goto <D.17763>; else goto <D.17764>;
  <D.17763>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "sgen-memory-governor.c", 342, "!(flags & ~SGEN_ALLOC_HEAP)");
  <D.17764>:
  mono_vfree (addr, size);
  {
    size_t __old_x;

    <D.17468>:
    __old_x = total_alloc;
    __old_x.65 = (void *) __old_x;
    D.17766 = __old_x - size;
    D.17767 = (void *) D.17766;
    D.17768 = InterlockedCompareExchangePointer (&total_alloc, D.17767, __old_x.65);
    __old_x.65 = (void *) __old_x;
    if (D.17768 != __old_x.65) goto <D.17468>; else goto <D.17469>;
    <D.17469>:
  }
  D.17769 = flags & 1;
  if (D.17769 != 0) goto <D.17770>; else goto <D.17771>;
  <D.17770>:
  <D.17771>:
}


mono_gc_get_heap_size ()
{
  int64_t D.17772;
  unsigned int total_alloc.66;

  total_alloc.66 = total_alloc;
  D.17772 = (int64_t) total_alloc.66;
  return D.17772;
}


sgen_memgov_release_space (mword size, int space)
{
  void * __old_x.67;
  unsigned int D.17776;
  void * D.17777;
  void * D.17778;

  {
    size_t __old_x;

    <D.17481>:
    __old_x = allocated_heap;
    __old_x.67 = (void *) __old_x;
    D.17776 = __old_x - size;
    D.17777 = (void *) D.17776;
    D.17778 = InterlockedCompareExchangePointer (&allocated_heap, D.17777, __old_x.67);
    __old_x.67 = (void *) __old_x;
    if (D.17778 != __old_x.67) goto <D.17481>; else goto <D.17482>;
    <D.17482>:
  }
}


sgen_memgov_try_alloc_space (mword size, int space)
{
  unsigned int D.17779;
  gboolean D.17782;
  void * __old_x.68;
  unsigned int D.17784;
  void * D.17785;
  void * D.17786;
  unsigned int allocated_heap.69;

  D.17779 = sgen_memgov_available_free_space ();
  if (D.17779 < size) goto <D.17780>; else goto <D.17781>;
  <D.17780>:
  D.17782 = 0;
  return D.17782;
  <D.17781>:
  {
    size_t __old_x;

    <D.17488>:
    __old_x = allocated_heap;
    __old_x.68 = (void *) __old_x;
    D.17784 = __old_x + size;
    D.17785 = (void *) D.17784;
    D.17786 = InterlockedCompareExchangePointer (&allocated_heap, D.17785, __old_x.68);
    __old_x.68 = (void *) __old_x;
    if (D.17786 != __old_x.68) goto <D.17488>; else goto <D.17489>;
    <D.17489>:
  }
  allocated_heap.69 = allocated_heap;
  mono_runtime_resource_check_limit (2, allocated_heap.69);
  D.17782 = 1;
  return D.17782;
}


sgen_memgov_init (glong max_heap, glong soft_limit, gboolean debug_allowance, double allowance_ratio, double save_target)
{
  unsigned int soft_limit.70;
  int sgen_nursery_size.71;
  int D.17797;
  long int D.17800;
  unsigned int max_heap_size.72;
  double D.17802;
  double default_allowance_nursery_size_ratio.73;
  double D.17804;
  unsigned int minor_collection_allowance.74;

  if (soft_limit != 0) goto <D.17789>; else goto <D.17790>;
  <D.17789>:
  soft_limit.70 = (unsigned int) soft_limit;
  soft_heap_limit = soft_limit.70;
  <D.17790>:
  debug_print_allowance = debug_allowance;
  if (max_heap == 0) goto <D.17792>; else goto <D.17793>;
  <D.17792>:
  return;
  <D.17793>:
  if (max_heap < soft_limit) goto <D.17794>; else goto <D.17795>;
  <D.17794>:
  sgen_env_var_error ("MONO_GC_PARAMS", "Setting to minimum.", "`max-heap-size` must be at least as large as `soft-heap-limit`.");
  max_heap = soft_limit;
  <D.17795>:
  sgen_nursery_size.71 = sgen_nursery_size;
  D.17797 = sgen_nursery_size.71 * 4;
  if (D.17797 > max_heap) goto <D.17798>; else goto <D.17799>;
  <D.17798>:
  sgen_env_var_error ("MONO_GC_PARAMS", "Setting to minimum.", "`max-heap-size` must be at least 4 times as large as `nursery size`.");
  sgen_nursery_size.71 = sgen_nursery_size;
  max_heap = sgen_nursery_size.71 * 4;
  <D.17799>:
  sgen_nursery_size.71 = sgen_nursery_size;
  D.17800 = max_heap - sgen_nursery_size.71;
  max_heap_size.72 = (unsigned int) D.17800;
  max_heap_size = max_heap_size.72;
  sgen_nursery_size.71 = sgen_nursery_size;
  D.17802 = (double) sgen_nursery_size.71;
  default_allowance_nursery_size_ratio.73 = default_allowance_nursery_size_ratio;
  D.17804 = D.17802 * default_allowance_nursery_size_ratio.73;
  minor_collection_allowance.74 = (unsigned int) D.17804;
  minor_collection_allowance = minor_collection_allowance.74;
  if (allowance_ratio != 0.0) goto <D.17806>; else goto <D.17807>;
  <D.17806>:
  default_allowance_nursery_size_ratio = allowance_ratio;
  <D.17807>:
  if (save_target != 0.0) goto <D.17808>; else goto <D.17809>;
  <D.17808>:
  save_target_ratio = save_target;
  <D.17809>:
}