sgen_need_major_collection (mword space_needed)
{
  int D.17478;
  gboolean D.17481;
  unsigned int los_memory_usage.0;
  unsigned int last_collection_los_memory_usage.1;
  unsigned int D.17484;
  int iftmp.2;
  unsigned int D.17489;
  unsigned int D.17491;
  int minor_collection_sections_alloced.3;
  unsigned int minor_collection_sections_alloced.4;
  unsigned int D.17494;
  unsigned int D.17495;
  unsigned int minor_collection_allowance.5;
  mword los_alloced;

  D.17478 = sgen_concurrent_collection_in_progress ();
  if (D.17478 != 0) goto <D.17479>; else goto <D.17480>;
  <D.17479>:
  D.17481 = 0;
  return D.17481;
  <D.17480>:
  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.17484 = MIN_EXPR <los_memory_usage.0, last_collection_los_memory_usage.1>;
  los_alloced = los_memory_usage.0 - D.17484;
  D.17489 = sgen_memgov_available_free_space ();
  if (D.17489 < space_needed) goto <D.17486>; else goto <D.17490>;
  <D.17490>:
  D.17491 = 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.17494 = D.17491 * minor_collection_sections_alloced.4;
  D.17495 = D.17494 + los_alloced;
  minor_collection_allowance.5 = minor_collection_allowance;
  if (D.17495 > minor_collection_allowance.5) goto <D.17486>; else goto <D.17487>;
  <D.17486>:
  iftmp.2 = 1;
  goto <D.17488>;
  <D.17487>:
  iftmp.2 = 0;
  <D.17488>:
  D.17481 = iftmp.2;
  return D.17481;
}


sgen_memgov_available_free_space ()
{
  mword D.17498;
  unsigned int max_heap_size.6;
  unsigned int allocated_heap.7;
  unsigned int D.17501;

  max_heap_size.6 = max_heap_size;
  max_heap_size.6 = max_heap_size;
  allocated_heap.7 = allocated_heap;
  D.17501 = MIN_EXPR <max_heap_size.6, allocated_heap.7>;
  D.17498 = max_heap_size.6 - D.17501;
  return D.17498;
}


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.17506;
  long int D.17507;
  long int D.17508;
  gboolean * D.17513;
  int D.17514;
  int sgen_nursery_size.9;
  double D.17520;
  double default_allowance_nursery_size_ratio.10;
  double D.17522;
  unsigned int minor_collection_allowance.11;
  int (*<T989>) (void) D.17524;
  int last_collection_old_num_major_sections.12;
  int D.17526;
  unsigned int last_collection_old_los_memory_usage.13;
  unsigned int last_collection_los_memory_usage.14;
  unsigned int D.17529;
  unsigned int D.17530;
  unsigned int num_major_sections.15;
  unsigned int D.17532;
  double D.17533;
  double D.17534;
  double D.17535;
  int minor_collection_sections_alloced.16;
  unsigned int minor_collection_sections_alloced.17;
  unsigned int D.17538;
  unsigned int last_collection_los_memory_alloced.18;
  unsigned int D.17540;
  double D.17541;
  double D.17542;
  unsigned int num_major_sections_saved.19;
  unsigned int D.17544;
  unsigned int D.17545;
  double D.17546;
  double D.17547;
  unsigned int D.17548;
  unsigned int los_memory_usage.20;
  unsigned int D.17550;
  unsigned int D.17551;
  unsigned int minor_collection_allowance.21;
  unsigned int minor_collection_allowance.22;
  unsigned int D.17554;
  unsigned int soft_heap_limit.23;
  unsigned int D.17561;
  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.17568;
  long int D.17569;
  long int D.17570;
  struct FILE * gc_debug_file.28;
  unsigned int D.17574;
  long int D.17575;
  long int old_major.29;
  long int last_collection_old_los_memory_usage.30;
  long int new_heap_size.31;
  long int new_major.32;
  long int last_collection_los_memory_usage.33;
  long int minor_collection_allowance.34;
  void (*<T46a>) (void) D.17586;
  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.17503>; else goto <D.17504>;
  <D.17503>:
  need_calculate_minor_collection_allowance.8 = need_calculate_minor_collection_allowance;
  D.17506 = need_calculate_minor_collection_allowance.8 == 0;
  D.17507 = (long int) D.17506;
  D.17508 = __builtin_expect (D.17507, 0);
  if (D.17508 != 0) goto <D.17509>; else goto <D.17510>;
  <D.17509>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "sgen-memory-governor.c", 92, "need_calculate_minor_collection_allowance");
  <D.17510>:
  <D.17504>:
  need_calculate_minor_collection_allowance.8 = need_calculate_minor_collection_allowance;
  if (need_calculate_minor_collection_allowance.8 == 0) goto <D.17511>; else goto <D.17512>;
  <D.17511>:
  return;
  <D.17512>:
  D.17513 = major_collector.have_swept;
  D.17514 = *D.17513;
  if (D.17514 == 0) goto <D.17515>; else goto <D.17516>;
  <D.17515>:
  if (overwrite != 0) goto <D.17517>; else goto <D.17518>;
  <D.17517>:
  sgen_nursery_size.9 = sgen_nursery_size;
  D.17520 = (double) sgen_nursery_size.9;
  default_allowance_nursery_size_ratio.10 = default_allowance_nursery_size_ratio;
  D.17522 = D.17520 * default_allowance_nursery_size_ratio.10;
  minor_collection_allowance.11 = (unsigned int) D.17522;
  minor_collection_allowance = minor_collection_allowance.11;
  <D.17518>:
  return;
  <D.17516>:
  D.17524 = major_collector.get_num_major_sections;
  num_major_sections = D.17524 ();
  last_collection_old_num_major_sections.12 = last_collection_old_num_major_sections;
  D.17526 = last_collection_old_num_major_sections.12 - num_major_sections;
  num_major_sections_saved = MAX_EXPR <D.17526, 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.17529 = last_collection_old_los_memory_usage.13 - last_collection_los_memory_usage.14;
  los_memory_saved = MAX_EXPR <D.17529, 1>;
  D.17530 = major_collector.section_size;
  num_major_sections.15 = (unsigned int) num_major_sections;
  new_major = D.17530 * 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.17532 = new_major + last_collection_los_memory_usage.14;
  D.17533 = (double) D.17532;
  D.17534 = D.17533 * 5.0e-1;
  save_target = (mword) D.17534;
  D.17535 = (double) save_target;
  D.17530 = 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.17538 = D.17530 * minor_collection_sections_alloced.17;
  last_collection_los_memory_alloced.18 = last_collection_los_memory_alloced;
  D.17540 = D.17538 + last_collection_los_memory_alloced.18;
  D.17541 = (double) D.17540;
  D.17542 = D.17535 * D.17541;
  D.17530 = major_collector.section_size;
  num_major_sections_saved.19 = (unsigned int) num_major_sections_saved;
  D.17544 = D.17530 * num_major_sections_saved.19;
  D.17545 = D.17544 + los_memory_saved;
  D.17546 = (double) D.17545;
  D.17547 = D.17542 / D.17546;
  allowance_target = double_to_mword_with_saturation (D.17547);
  sgen_nursery_size.9 = sgen_nursery_size;
  D.17520 = (double) sgen_nursery_size.9;
  default_allowance_nursery_size_ratio.10 = default_allowance_nursery_size_ratio;
  D.17522 = D.17520 * default_allowance_nursery_size_ratio.10;
  minor_collection_allowance.11 = (unsigned int) D.17522;
  D.17530 = major_collector.section_size;
  num_major_sections.15 = (unsigned int) num_major_sections;
  D.17548 = D.17530 * num_major_sections.15;
  los_memory_usage.20 = los_memory_usage;
  D.17550 = D.17548 + los_memory_usage.20;
  D.17551 = MIN_EXPR <D.17550, allowance_target>;
  minor_collection_allowance.21 = MAX_EXPR <minor_collection_allowance.11, D.17551>;
  minor_collection_allowance = minor_collection_allowance.21;
  minor_collection_allowance.22 = minor_collection_allowance;
  D.17554 = new_heap_size + minor_collection_allowance.22;
  soft_heap_limit.23 = soft_heap_limit;
  if (D.17554 > soft_heap_limit.23) goto <D.17556>; else goto <D.17557>;
  <D.17556>:
  soft_heap_limit.23 = soft_heap_limit;
  if (new_heap_size > soft_heap_limit.23) goto <D.17558>; else goto <D.17559>;
  <D.17558>:
  sgen_nursery_size.9 = sgen_nursery_size;
  D.17520 = (double) sgen_nursery_size.9;
  default_allowance_nursery_size_ratio.10 = default_allowance_nursery_size_ratio;
  D.17522 = D.17520 * default_allowance_nursery_size_ratio.10;
  minor_collection_allowance.11 = (unsigned int) D.17522;
  minor_collection_allowance = minor_collection_allowance.11;
  goto <D.17560>;
  <D.17559>:
  sgen_nursery_size.9 = sgen_nursery_size;
  D.17520 = (double) sgen_nursery_size.9;
  default_allowance_nursery_size_ratio.10 = default_allowance_nursery_size_ratio;
  D.17522 = D.17520 * default_allowance_nursery_size_ratio.10;
  minor_collection_allowance.11 = (unsigned int) D.17522;
  soft_heap_limit.23 = soft_heap_limit;
  D.17561 = soft_heap_limit.23 - new_heap_size;
  minor_collection_allowance.24 = MAX_EXPR <minor_collection_allowance.11, D.17561>;
  minor_collection_allowance = minor_collection_allowance.24;
  <D.17560>:
  <D.17557>:
  debug_print_allowance.25 = debug_print_allowance;
  if (debug_print_allowance.25 != 0) goto <D.17564>; else goto <D.17565>;
  <D.17564>:
  {
    mword old_major;

    D.17530 = 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.17530 * last_collection_old_num_major_sections.26;
    gc_debug_level.27 = gc_debug_level;
    D.17568 = gc_debug_level.27 > 0;
    D.17569 = (long int) D.17568;
    D.17570 = __builtin_expect (D.17569, 0);
    if (D.17570 != 0) goto <D.17571>; else goto <D.17572>;
    <D.17571>:
    gc_debug_file.28 = gc_debug_file;
    last_collection_old_los_memory_usage.13 = last_collection_old_los_memory_usage;
    D.17574 = old_major + last_collection_old_los_memory_usage.13;
    D.17575 = (long int) D.17574;
    old_major.29 = (long int) old_major;
    last_collection_old_los_memory_usage.13 = last_collection_old_los_memory_usage;
    last_collection_old_los_memory_usage.30 = (long int) last_collection_old_los_memory_usage.13;
    fprintf (gc_debug_file.28, "Before collection: %ld bytes (%ld major, %ld LOS)\n", D.17575, old_major.29, last_collection_old_los_memory_usage.30);
    gc_debug_file.28 = gc_debug_file;
    fflush (gc_debug_file.28);
    <D.17572>:
    gc_debug_level.27 = gc_debug_level;
    D.17568 = gc_debug_level.27 > 0;
    D.17569 = (long int) D.17568;
    D.17570 = __builtin_expect (D.17569, 0);
    if (D.17570 != 0) goto <D.17578>; else goto <D.17579>;
    <D.17578>:
    gc_debug_file.28 = gc_debug_file;
    new_heap_size.31 = (long int) new_heap_size;
    new_major.32 = (long int) new_major;
    last_collection_los_memory_usage.14 = last_collection_los_memory_usage;
    last_collection_los_memory_usage.33 = (long int) last_collection_los_memory_usage.14;
    fprintf (gc_debug_file.28, "After collection: %ld bytes (%ld major, %ld LOS)\n", new_heap_size.31, new_major.32, last_collection_los_memory_usage.33);
    gc_debug_file.28 = gc_debug_file;
    fflush (gc_debug_file.28);
    <D.17579>:
    gc_debug_level.27 = gc_debug_level;
    D.17568 = gc_debug_level.27 > 0;
    D.17569 = (long int) D.17568;
    D.17570 = __builtin_expect (D.17569, 0);
    if (D.17570 != 0) goto <D.17583>; else goto <D.17584>;
    <D.17583>:
    gc_debug_file.28 = gc_debug_file;
    minor_collection_allowance.22 = minor_collection_allowance;
    minor_collection_allowance.34 = (long int) minor_collection_allowance.22;
    fprintf (gc_debug_file.28, "Allowance: %ld bytes\n", minor_collection_allowance.34);
    gc_debug_file.28 = gc_debug_file;
    fflush (gc_debug_file.28);
    <D.17584>:
  }
  <D.17565>:
  D.17586 = major_collector.have_computed_minor_collection_allowance;
  if (D.17586 != 0B) goto <D.17587>; else goto <D.17588>;
  <D.17587>:
  D.17586 = major_collector.have_computed_minor_collection_allowance;
  D.17586 ();
  <D.17588>:
  need_calculate_minor_collection_allowance = 0;
}


double_to_mword_with_saturation (double value)
{
  mword D.17592;

  if (value >= 4.294967295e+9) goto <D.17590>; else goto <D.17591>;
  <D.17590>:
  D.17592 = 4294967295;
  return D.17592;
  <D.17591>:
  D.17592 = (mword) value;
  return D.17592;
}


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

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


sgen_memgov_minor_collection_end ()
{

}


sgen_memgov_major_collection_start ()
{
  struct SgenMajorCollector * D.17596;
  int (*<T989>) (void) D.17597;
  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.17601;
  unsigned int last_collection_los_memory_alloced.38;

  D.17596 = sgen_get_major_collector ();
  D.17597 = D.17596->get_num_major_sections;
  last_collection_old_num_major_sections.35 = D.17597 ();
  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.17601 = MIN_EXPR <los_memory_usage.36, last_collection_los_memory_usage.37>;
  last_collection_los_memory_alloced.38 = los_memory_usage.36 - D.17601;
  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 (*<T989>) (void) D.17604;
  int last_major_num_sections.40;
  unsigned int los_memory_usage.41;
  int los_memory_usage.42;

  D.17604 = major_collector.get_num_major_sections;
  last_major_num_sections.40 = D.17604 ();
  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.17609;
  struct GGTimingInfo * D.17610;
  int D.17611;
  int i;

  i = 0;
  goto <D.17403>;
  <D.17402>:
  i.43 = (unsigned int) i;
  D.17609 = i.43 * 40;
  D.17610 = info + D.17609;
  D.17611 = D.17610->generation;
  if (D.17611 != -1) goto <D.17612>; else goto <D.17613>;
  <D.17612>:
  i.43 = (unsigned int) i;
  D.17609 = i.43 * 40;
  D.17610 = info + D.17609;
  log_timming (D.17610);
  <D.17613>:
  i = i + 1;
  <D.17403>:
  if (i < info_count) goto <D.17402>; else goto <D.17404>;
  <D.17404>:
}


log_timming (struct GGTimingInfo * info)
{
  int (*<T989>) (void) D.17614;
  int D.17615;
  long long int D.17618;
  float D.17619;
  float D.17620;
  double D.17621;
  long long int D.17622;
  int D.17623;
  float D.17624;
  float D.17625;
  double D.17626;
  int D.17627;
  const char * iftmp.44;
  const char * iftmp.45;
  const char * D.17635;
  long long int D.17639;
  int D.17640;
  float D.17641;
  float D.17642;
  double D.17643;
  unsigned int D.17644;
  unsigned int num_major_sections.46;
  unsigned int D.17646;
  unsigned int D.17647;
  int last_major_num_sections.47;
  unsigned int last_major_num_sections.48;
  unsigned int D.17650;
  unsigned int D.17651;
  unsigned int los_memory_usage.49;
  unsigned int D.17653;
  int last_los_memory_usage.50;
  int D.17655;
  const char * iftmp.51;
  const char * iftmp.52;
  int D.17665;
  unsigned int D.17666;
  unsigned int D.17667;
  unsigned int D.17668;
  int num_major_sections;
  char full_timing_buff[1024];

  try
    {
      D.17614 = major_collector.get_num_major_sections;
      num_major_sections = D.17614 ();
      full_timing_buff[0] = 0;
      D.17615 = info->is_overflow;
      if (D.17615 == 0) goto <D.17616>; else goto <D.17617>;
      <D.17616>:
      D.17618 = info->stw_time;
      D.17619 = (float) D.17618;
      D.17620 = D.17619 / 1.0e+3;
      D.17621 = (double) D.17620;
      D.17622 = info->bridge_time;
      D.17623 = (int) D.17622;
      D.17624 = (float) D.17623;
      D.17625 = D.17624 / 1.0e+3;
      D.17626 = (double) D.17625;
      sprintf (&full_timing_buff, "total %.2fms, bridge %.2fms", D.17621, D.17626);
      <D.17617>:
      D.17627 = info->generation;
      if (D.17627 == 1) goto <D.17628>; else goto <D.17629>;
      <D.17628>:
      D.17615 = info->is_overflow;
      if (D.17615 != 0) goto <D.17631>; else goto <D.17632>;
      <D.17631>:
      iftmp.44 = "_OVERFLOW";
      goto <D.17633>;
      <D.17632>:
      iftmp.44 = "";
      <D.17633>:
      D.17635 = info->reason;
      if (D.17635 != 0B) goto <D.17636>; else goto <D.17637>;
      <D.17636>:
      iftmp.45 = info->reason;
      goto <D.17638>;
      <D.17637>:
      iftmp.45 = "";
      <D.17638>:
      D.17639 = info->total_time;
      D.17640 = (int) D.17639;
      D.17641 = (float) D.17640;
      D.17642 = D.17641 / 1.0e+3;
      D.17643 = (double) D.17642;
      D.17644 = major_collector.section_size;
      num_major_sections.46 = (unsigned int) num_major_sections;
      D.17646 = D.17644 * num_major_sections.46;
      D.17647 = D.17646 / 1024;
      D.17644 = major_collector.section_size;
      last_major_num_sections.47 = last_major_num_sections;
      last_major_num_sections.48 = (unsigned int) last_major_num_sections.47;
      D.17650 = D.17644 * last_major_num_sections.48;
      D.17651 = D.17650 / 1024;
      los_memory_usage.49 = los_memory_usage;
      D.17653 = los_memory_usage.49 / 1024;
      last_los_memory_usage.50 = last_los_memory_usage;
      D.17655 = last_los_memory_usage.50 / 1024;
      mono_trace (64, 8, "GC_MAJOR%s: (%s) pause %.2fms, %s major %dK/%dK los %dK/%dK", iftmp.44, iftmp.45, D.17643, &full_timing_buff, D.17647, D.17651, D.17653, D.17655);
      goto <D.17656>;
      <D.17629>:
      D.17615 = info->is_overflow;
      if (D.17615 != 0) goto <D.17658>; else goto <D.17659>;
      <D.17658>:
      iftmp.51 = "_OVERFLOW";
      goto <D.17660>;
      <D.17659>:
      iftmp.51 = "";
      <D.17660>:
      D.17635 = info->reason;
      if (D.17635 != 0B) goto <D.17662>; else goto <D.17663>;
      <D.17662>:
      iftmp.52 = info->reason;
      goto <D.17664>;
      <D.17663>:
      iftmp.52 = "";
      <D.17664>:
      D.17639 = info->total_time;
      D.17640 = (int) D.17639;
      D.17641 = (float) D.17640;
      D.17642 = D.17641 / 1.0e+3;
      D.17643 = (double) D.17642;
      last_major_num_sections.47 = last_major_num_sections;
      D.17665 = num_major_sections - last_major_num_sections.47;
      D.17666 = (unsigned int) D.17665;
      D.17644 = major_collector.section_size;
      D.17667 = D.17666 * D.17644;
      D.17668 = D.17667 / 1024;
      D.17644 = major_collector.section_size;
      num_major_sections.46 = (unsigned int) num_major_sections;
      D.17646 = D.17644 * num_major_sections.46;
      D.17647 = D.17646 / 1024;
      los_memory_usage.49 = los_memory_usage;
      D.17653 = los_memory_usage.49 / 1024;
      mono_trace (64, 8, "GC_MINOR%s: (%s) pause %.2fms, %s promoted %dK major %dK los %dK", iftmp.51, iftmp.52, D.17643, &full_timing_buff, D.17668, D.17647, D.17653);
      <D.17656>:
    }
  finally
    {
      full_timing_buff = {CLOBBER};
    }
}


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

  D.17670 = __builtin_object_size (__s, 1);
  D.17669 = __builtin___sprintf_chk (__s, 1, D.17670, __fmt, __builtin_va_arg_pack ());
  return D.17669;
}


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

  D.17674 = minor_collection_allowance;
  return D.17674;
}


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

  pthread_mutex_lock (&gc_mutex);
  D.17676 = (unsigned int) value;
  memory_pressure.55 = memory_pressure;
  memory_pressure.56 = D.17676 + 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)
{
  struct _IO_FILE * stderr.57;

  if (ptr != 0B) goto <D.17679>; else goto <D.17681>;
  <D.17681>:
  if (assert_description == 0B) goto <D.17679>; else goto <D.17680>;
  <D.17679>:
  return;
  <D.17680>:
  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.17684;
  _Bool D.17685;
  long int D.17686;
  long int D.17687;
  int flags.58;
  int D.17691;
  long unsigned int D.17692;
  int D.17693;
  unsigned int D.17696;
  void * D.17697;
  void * __old_x.59;
  void * D.17699;
  unsigned int D.17700;
  void * D.17703;
  void * ptr;

  D.17684 = flags & 4294967292;
  D.17685 = D.17684 != 0;
  D.17686 = (long int) D.17685;
  D.17687 = __builtin_expect (D.17686, 0);
  if (D.17687 != 0) goto <D.17688>; else goto <D.17689>;
  <D.17688>:
  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.17689>:
  flags.58 = (int) flags;
  D.17691 = flags.58 & 2;
  D.17692 = prot_flags_for_activate (D.17691);
  D.17693 = (int) D.17692;
  ptr = mono_valloc (0B, size, D.17693);
  sgen_assert_memory_alloc (ptr, size, assert_description);
  if (ptr != 0B) goto <D.17694>; else goto <D.17695>;
  <D.17694>:
  {
    size_t __old_x;

    <D.17430>:
    __old_x = total_alloc;
    D.17696 = __old_x + size;
    D.17697 = (void *) D.17696;
    __old_x.59 = (void *) __old_x;
    D.17699 = InterlockedCompareExchangePointer (&total_alloc, D.17697, __old_x.59);
    __old_x.59 = (void *) __old_x;
    if (D.17699 != __old_x.59) goto <D.17430>; else goto <D.17431>;
    <D.17431>:
  }
  D.17700 = flags & 1;
  if (D.17700 != 0) goto <D.17701>; else goto <D.17702>;
  <D.17701>:
  <D.17702>:
  <D.17695>:
  D.17703 = ptr;
  return D.17703;
}


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

  if (activate != 0) goto <D.17706>; else goto <D.17707>;
  <D.17706>:
  iftmp.60 = 3;
  goto <D.17708>;
  <D.17707>:
  iftmp.60 = 0;
  <D.17708>:
  prot_flags = iftmp.60;
  D.17709 = prot_flags | 80;
  return D.17709;
}


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

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


sgen_alloc_os_memory_aligned (size_t size, mword alignment, SgenAllocFlags flags, const char * assert_description)
{
  unsigned int D.17716;
  _Bool D.17717;
  long int D.17718;
  long int D.17719;
  int flags.63;
  int D.17723;
  long unsigned int D.17724;
  int D.17725;
  unsigned int D.17728;
  void * D.17729;
  void * __old_x.64;
  void * D.17731;
  unsigned int D.17732;
  void * D.17735;
  void * ptr;

  D.17716 = flags & 4294967292;
  D.17717 = D.17716 != 0;
  D.17718 = (long int) D.17717;
  D.17719 = __builtin_expect (D.17718, 0);
  if (D.17719 != 0) goto <D.17720>; else goto <D.17721>;
  <D.17720>:
  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.17721>:
  flags.63 = (int) flags;
  D.17723 = flags.63 & 2;
  D.17724 = prot_flags_for_activate (D.17723);
  D.17725 = (int) D.17724;
  ptr = mono_valloc_aligned (size, alignment, D.17725);
  sgen_assert_memory_alloc (ptr, size, assert_description);
  if (ptr != 0B) goto <D.17726>; else goto <D.17727>;
  <D.17726>:
  {
    size_t __old_x;

    <D.17440>:
    __old_x = total_alloc;
    D.17728 = __old_x + size;
    D.17729 = (void *) D.17728;
    __old_x.64 = (void *) __old_x;
    D.17731 = InterlockedCompareExchangePointer (&total_alloc, D.17729, __old_x.64);
    __old_x.64 = (void *) __old_x;
    if (D.17731 != __old_x.64) goto <D.17440>; else goto <D.17441>;
    <D.17441>:
  }
  D.17732 = flags & 1;
  if (D.17732 != 0) goto <D.17733>; else goto <D.17734>;
  <D.17733>:
  <D.17734>:
  <D.17727>:
  D.17735 = ptr;
  return D.17735;
}


sgen_free_os_memory (void * addr, size_t size, SgenAllocFlags flags)
{
  unsigned int D.17737;
  _Bool D.17738;
  long int D.17739;
  long int D.17740;
  unsigned int D.17743;
  void * D.17744;
  void * __old_x.65;
  void * D.17746;
  unsigned int D.17747;

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

    <D.17448>:
    __old_x = total_alloc;
    D.17743 = __old_x - size;
    D.17744 = (void *) D.17743;
    __old_x.65 = (void *) __old_x;
    D.17746 = InterlockedCompareExchangePointer (&total_alloc, D.17744, __old_x.65);
    __old_x.65 = (void *) __old_x;
    if (D.17746 != __old_x.65) goto <D.17448>; else goto <D.17449>;
    <D.17449>:
  }
  D.17747 = flags & 1;
  if (D.17747 != 0) goto <D.17748>; else goto <D.17749>;
  <D.17748>:
  <D.17749>:
}


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

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


sgen_memgov_release_space (mword size, int space)
{
  unsigned int D.17753;
  void * D.17754;
  void * __old_x.67;
  void * D.17756;

  {
    size_t __old_x;

    <D.17461>:
    __old_x = allocated_heap;
    D.17753 = __old_x - size;
    D.17754 = (void *) D.17753;
    __old_x.67 = (void *) __old_x;
    D.17756 = InterlockedCompareExchangePointer (&allocated_heap, D.17754, __old_x.67);
    __old_x.67 = (void *) __old_x;
    if (D.17756 != __old_x.67) goto <D.17461>; else goto <D.17462>;
    <D.17462>:
  }
}


sgen_memgov_try_alloc_space (mword size, int space)
{
  unsigned int D.17757;
  gboolean D.17760;
  unsigned int D.17761;
  void * D.17762;
  void * __old_x.68;
  void * D.17764;
  unsigned int allocated_heap.69;

  D.17757 = sgen_memgov_available_free_space ();
  if (D.17757 < size) goto <D.17758>; else goto <D.17759>;
  <D.17758>:
  D.17760 = 0;
  return D.17760;
  <D.17759>:
  {
    size_t __old_x;

    <D.17468>:
    __old_x = allocated_heap;
    D.17761 = __old_x + size;
    D.17762 = (void *) D.17761;
    __old_x.68 = (void *) __old_x;
    D.17764 = InterlockedCompareExchangePointer (&allocated_heap, D.17762, __old_x.68);
    __old_x.68 = (void *) __old_x;
    if (D.17764 != __old_x.68) goto <D.17468>; else goto <D.17469>;
    <D.17469>:
  }
  allocated_heap.69 = allocated_heap;
  mono_runtime_resource_check_limit (2, allocated_heap.69);
  D.17760 = 1;
  return D.17760;
}


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.17775;
  long int D.17778;
  unsigned int max_heap_size.72;
  double D.17780;
  double default_allowance_nursery_size_ratio.73;
  double D.17782;
  unsigned int minor_collection_allowance.74;

  if (soft_limit != 0) goto <D.17767>; else goto <D.17768>;
  <D.17767>:
  soft_limit.70 = (unsigned int) soft_limit;
  soft_heap_limit = soft_limit.70;
  <D.17768>:
  debug_print_allowance = debug_allowance;
  if (max_heap == 0) goto <D.17770>; else goto <D.17771>;
  <D.17770>:
  return;
  <D.17771>:
  if (max_heap < soft_limit) goto <D.17772>; else goto <D.17773>;
  <D.17772>:
  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.17773>:
  sgen_nursery_size.71 = sgen_nursery_size;
  D.17775 = sgen_nursery_size.71 * 4;
  if (D.17775 > max_heap) goto <D.17776>; else goto <D.17777>;
  <D.17776>:
  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.17777>:
  sgen_nursery_size.71 = sgen_nursery_size;
  D.17778 = max_heap - sgen_nursery_size.71;
  max_heap_size.72 = (unsigned int) D.17778;
  max_heap_size = max_heap_size.72;
  sgen_nursery_size.71 = sgen_nursery_size;
  D.17780 = (double) sgen_nursery_size.71;
  default_allowance_nursery_size_ratio.73 = default_allowance_nursery_size_ratio;
  D.17782 = D.17780 * default_allowance_nursery_size_ratio.73;
  minor_collection_allowance.74 = (unsigned int) D.17782;
  minor_collection_allowance = minor_collection_allowance.74;
  if (allowance_ratio != 0.0) goto <D.17784>; else goto <D.17785>;
  <D.17784>:
  default_allowance_nursery_size_ratio = allowance_ratio;
  <D.17785>:
  if (save_target != 0.0) goto <D.17786>; else goto <D.17787>;
  <D.17786>:
  save_target_ratio = save_target;
  <D.17787>:
}