sgen_need_major_collection (mword space_needed)
{
  int D.20063;
  gboolean D.20066;
  unsigned int los_memory_usage.0;
  unsigned int last_collection_los_memory_usage.1;
  unsigned int D.20069;
  int iftmp.2;
  unsigned int D.20074;
  unsigned int D.20076;
  int minor_collection_sections_alloced.3;
  unsigned int minor_collection_sections_alloced.4;
  unsigned int D.20079;
  unsigned int D.20080;
  unsigned int minor_collection_allowance.5;
  mword los_alloced;

  D.20063 = sgen_concurrent_collection_in_progress ();
  if (D.20063 != 0) goto <D.20064>; else goto <D.20065>;
  <D.20064>:
  D.20066 = 0;
  return D.20066;
  <D.20065>:
  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.20069 = MIN_EXPR <los_memory_usage.0, last_collection_los_memory_usage.1>;
  los_alloced = los_memory_usage.0 - D.20069;
  D.20074 = sgen_memgov_available_free_space ();
  if (D.20074 < space_needed) goto <D.20071>; else goto <D.20075>;
  <D.20075>:
  D.20076 = 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.20079 = D.20076 * minor_collection_sections_alloced.4;
  D.20080 = D.20079 + los_alloced;
  minor_collection_allowance.5 = minor_collection_allowance;
  if (D.20080 > minor_collection_allowance.5) goto <D.20071>; else goto <D.20072>;
  <D.20071>:
  iftmp.2 = 1;
  goto <D.20073>;
  <D.20072>:
  iftmp.2 = 0;
  <D.20073>:
  D.20066 = iftmp.2;
  return D.20066;
}


sgen_memgov_available_free_space ()
{
  mword D.20083;
  unsigned int max_heap_size.6;
  unsigned int allocated_heap.7;
  unsigned int D.20086;

  max_heap_size.6 = max_heap_size;
  max_heap_size.6 = max_heap_size;
  allocated_heap.7 = allocated_heap;
  D.20086 = MIN_EXPR <max_heap_size.6, allocated_heap.7>;
  D.20083 = max_heap_size.6 - D.20086;
  return D.20083;
}


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.20091;
  long int D.20092;
  long int D.20093;
  gboolean * D.20098;
  int D.20099;
  int sgen_nursery_size.9;
  double D.20105;
  double default_allowance_nursery_size_ratio.10;
  double D.20107;
  unsigned int minor_collection_allowance.11;
  int (*<T1418>) (void) D.20109;
  int last_collection_old_num_major_sections.12;
  int D.20111;
  unsigned int last_collection_old_los_memory_usage.13;
  unsigned int last_collection_los_memory_usage.14;
  unsigned int D.20114;
  unsigned int D.20115;
  unsigned int num_major_sections.15;
  unsigned int D.20117;
  double D.20118;
  double D.20119;
  double D.20120;
  int minor_collection_sections_alloced.16;
  unsigned int minor_collection_sections_alloced.17;
  unsigned int D.20123;
  unsigned int last_collection_los_memory_alloced.18;
  unsigned int D.20125;
  double D.20126;
  double D.20127;
  unsigned int num_major_sections_saved.19;
  unsigned int D.20129;
  unsigned int D.20130;
  double D.20131;
  double D.20132;
  unsigned int D.20133;
  unsigned int los_memory_usage.20;
  unsigned int D.20135;
  unsigned int D.20136;
  unsigned int minor_collection_allowance.21;
  unsigned int minor_collection_allowance.22;
  unsigned int D.20139;
  unsigned int soft_heap_limit.23;
  unsigned int D.20146;
  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.20153;
  long int D.20154;
  long int D.20155;
  struct FILE * gc_debug_file.28;
  unsigned int D.20159;
  long int D.20160;
  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 (*<Tf23>) (void) D.20171;
  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.20088>; else goto <D.20089>;
  <D.20088>:
  need_calculate_minor_collection_allowance.8 = need_calculate_minor_collection_allowance;
  D.20091 = need_calculate_minor_collection_allowance.8 == 0;
  D.20092 = (long int) D.20091;
  D.20093 = __builtin_expect (D.20092, 0);
  if (D.20093 != 0) goto <D.20094>; else goto <D.20095>;
  <D.20094>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "sgen-memory-governor.c", 92, "need_calculate_minor_collection_allowance");
  <D.20095>:
  <D.20089>:
  need_calculate_minor_collection_allowance.8 = need_calculate_minor_collection_allowance;
  if (need_calculate_minor_collection_allowance.8 == 0) goto <D.20096>; else goto <D.20097>;
  <D.20096>:
  return;
  <D.20097>:
  D.20098 = major_collector.have_swept;
  D.20099 = *D.20098;
  if (D.20099 == 0) goto <D.20100>; else goto <D.20101>;
  <D.20100>:
  if (overwrite != 0) goto <D.20102>; else goto <D.20103>;
  <D.20102>:
  sgen_nursery_size.9 = sgen_nursery_size;
  D.20105 = (double) sgen_nursery_size.9;
  default_allowance_nursery_size_ratio.10 = default_allowance_nursery_size_ratio;
  D.20107 = D.20105 * default_allowance_nursery_size_ratio.10;
  minor_collection_allowance.11 = (unsigned int) D.20107;
  minor_collection_allowance = minor_collection_allowance.11;
  <D.20103>:
  return;
  <D.20101>:
  D.20109 = major_collector.get_num_major_sections;
  num_major_sections = D.20109 ();
  last_collection_old_num_major_sections.12 = last_collection_old_num_major_sections;
  D.20111 = last_collection_old_num_major_sections.12 - num_major_sections;
  num_major_sections_saved = MAX_EXPR <D.20111, 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.20114 = last_collection_old_los_memory_usage.13 - last_collection_los_memory_usage.14;
  los_memory_saved = MAX_EXPR <D.20114, 1>;
  D.20115 = major_collector.section_size;
  num_major_sections.15 = (unsigned int) num_major_sections;
  new_major = D.20115 * 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.20117 = new_major + last_collection_los_memory_usage.14;
  D.20118 = (double) D.20117;
  D.20119 = D.20118 * 5.0e-1;
  save_target = (mword) D.20119;
  D.20120 = (double) save_target;
  D.20115 = 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.20123 = D.20115 * minor_collection_sections_alloced.17;
  last_collection_los_memory_alloced.18 = last_collection_los_memory_alloced;
  D.20125 = D.20123 + last_collection_los_memory_alloced.18;
  D.20126 = (double) D.20125;
  D.20127 = D.20120 * D.20126;
  D.20115 = major_collector.section_size;
  num_major_sections_saved.19 = (unsigned int) num_major_sections_saved;
  D.20129 = D.20115 * num_major_sections_saved.19;
  D.20130 = D.20129 + los_memory_saved;
  D.20131 = (double) D.20130;
  D.20132 = D.20127 / D.20131;
  allowance_target = double_to_mword_with_saturation (D.20132);
  sgen_nursery_size.9 = sgen_nursery_size;
  D.20105 = (double) sgen_nursery_size.9;
  default_allowance_nursery_size_ratio.10 = default_allowance_nursery_size_ratio;
  D.20107 = D.20105 * default_allowance_nursery_size_ratio.10;
  minor_collection_allowance.11 = (unsigned int) D.20107;
  D.20115 = major_collector.section_size;
  num_major_sections.15 = (unsigned int) num_major_sections;
  D.20133 = D.20115 * num_major_sections.15;
  los_memory_usage.20 = los_memory_usage;
  D.20135 = D.20133 + los_memory_usage.20;
  D.20136 = MIN_EXPR <D.20135, allowance_target>;
  minor_collection_allowance.21 = MAX_EXPR <minor_collection_allowance.11, D.20136>;
  minor_collection_allowance = minor_collection_allowance.21;
  minor_collection_allowance.22 = minor_collection_allowance;
  D.20139 = new_heap_size + minor_collection_allowance.22;
  soft_heap_limit.23 = soft_heap_limit;
  if (D.20139 > soft_heap_limit.23) goto <D.20141>; else goto <D.20142>;
  <D.20141>:
  soft_heap_limit.23 = soft_heap_limit;
  if (new_heap_size > soft_heap_limit.23) goto <D.20143>; else goto <D.20144>;
  <D.20143>:
  sgen_nursery_size.9 = sgen_nursery_size;
  D.20105 = (double) sgen_nursery_size.9;
  default_allowance_nursery_size_ratio.10 = default_allowance_nursery_size_ratio;
  D.20107 = D.20105 * default_allowance_nursery_size_ratio.10;
  minor_collection_allowance.11 = (unsigned int) D.20107;
  minor_collection_allowance = minor_collection_allowance.11;
  goto <D.20145>;
  <D.20144>:
  sgen_nursery_size.9 = sgen_nursery_size;
  D.20105 = (double) sgen_nursery_size.9;
  default_allowance_nursery_size_ratio.10 = default_allowance_nursery_size_ratio;
  D.20107 = D.20105 * default_allowance_nursery_size_ratio.10;
  minor_collection_allowance.11 = (unsigned int) D.20107;
  soft_heap_limit.23 = soft_heap_limit;
  D.20146 = soft_heap_limit.23 - new_heap_size;
  minor_collection_allowance.24 = MAX_EXPR <minor_collection_allowance.11, D.20146>;
  minor_collection_allowance = minor_collection_allowance.24;
  <D.20145>:
  <D.20142>:
  debug_print_allowance.25 = debug_print_allowance;
  if (debug_print_allowance.25 != 0) goto <D.20149>; else goto <D.20150>;
  <D.20149>:
  {
    mword old_major;

    D.20115 = 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.20115 * last_collection_old_num_major_sections.26;
    gc_debug_level.27 = gc_debug_level;
    D.20153 = gc_debug_level.27 > 0;
    D.20154 = (long int) D.20153;
    D.20155 = __builtin_expect (D.20154, 0);
    if (D.20155 != 0) goto <D.20156>; else goto <D.20157>;
    <D.20156>:
    gc_debug_file.28 = gc_debug_file;
    last_collection_old_los_memory_usage.13 = last_collection_old_los_memory_usage;
    D.20159 = old_major + last_collection_old_los_memory_usage.13;
    D.20160 = (long int) D.20159;
    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.20160, old_major.29, last_collection_old_los_memory_usage.30);
    gc_debug_file.28 = gc_debug_file;
    fflush (gc_debug_file.28);
    <D.20157>:
    gc_debug_level.27 = gc_debug_level;
    D.20153 = gc_debug_level.27 > 0;
    D.20154 = (long int) D.20153;
    D.20155 = __builtin_expect (D.20154, 0);
    if (D.20155 != 0) goto <D.20163>; else goto <D.20164>;
    <D.20163>:
    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.20164>:
    gc_debug_level.27 = gc_debug_level;
    D.20153 = gc_debug_level.27 > 0;
    D.20154 = (long int) D.20153;
    D.20155 = __builtin_expect (D.20154, 0);
    if (D.20155 != 0) goto <D.20168>; else goto <D.20169>;
    <D.20168>:
    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.20169>:
  }
  <D.20150>:
  D.20171 = major_collector.have_computed_minor_collection_allowance;
  if (D.20171 != 0B) goto <D.20172>; else goto <D.20173>;
  <D.20172>:
  D.20171 = major_collector.have_computed_minor_collection_allowance;
  D.20171 ();
  <D.20173>:
  need_calculate_minor_collection_allowance = 0;
}


double_to_mword_with_saturation (double value)
{
  mword D.20177;

  if (value >= 4.294967295e+9) goto <D.20175>; else goto <D.20176>;
  <D.20175>:
  D.20177 = 4294967295;
  return D.20177;
  <D.20176>:
  D.20177 = (mword) value;
  return D.20177;
}


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

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


sgen_memgov_minor_collection_end ()
{

}


sgen_memgov_major_collection_start ()
{
  struct SgenMajorCollector * D.20181;
  int (*<T1418>) (void) D.20182;
  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.20186;
  unsigned int last_collection_los_memory_alloced.38;

  D.20181 = sgen_get_major_collector ();
  D.20182 = D.20181->get_num_major_sections;
  last_collection_old_num_major_sections.35 = D.20182 ();
  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.20186 = MIN_EXPR <los_memory_usage.36, last_collection_los_memory_usage.37>;
  last_collection_los_memory_alloced.38 = los_memory_usage.36 - D.20186;
  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 (*<T1418>) (void) D.20189;
  int last_major_num_sections.40;
  unsigned int los_memory_usage.41;
  int los_memory_usage.42;

  D.20189 = major_collector.get_num_major_sections;
  last_major_num_sections.40 = D.20189 ();
  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.20194;
  struct GGTimingInfo * D.20195;
  int D.20196;
  int i;

  i = 0;
  goto <D.19986>;
  <D.19985>:
  i.43 = (unsigned int) i;
  D.20194 = i.43 * 40;
  D.20195 = info + D.20194;
  D.20196 = D.20195->generation;
  if (D.20196 != -1) goto <D.20197>; else goto <D.20198>;
  <D.20197>:
  i.43 = (unsigned int) i;
  D.20194 = i.43 * 40;
  D.20195 = info + D.20194;
  log_timming (D.20195);
  <D.20198>:
  i = i + 1;
  <D.19986>:
  if (i < info_count) goto <D.19985>; else goto <D.19987>;
  <D.19987>:
}


log_timming (struct GGTimingInfo * info)
{
  int (*<T1418>) (void) D.20199;
  int D.20200;
  long long int D.20203;
  float D.20204;
  float D.20205;
  double D.20206;
  long long int D.20207;
  int D.20208;
  float D.20209;
  float D.20210;
  double D.20211;
  int D.20212;
  const char * iftmp.44;
  const char * iftmp.45;
  const char * D.20220;
  long long int D.20224;
  int D.20225;
  float D.20226;
  float D.20227;
  double D.20228;
  unsigned int D.20229;
  unsigned int num_major_sections.46;
  unsigned int D.20231;
  unsigned int D.20232;
  int last_major_num_sections.47;
  unsigned int last_major_num_sections.48;
  unsigned int D.20235;
  unsigned int D.20236;
  unsigned int los_memory_usage.49;
  unsigned int D.20238;
  int last_los_memory_usage.50;
  int D.20240;
  const char * iftmp.51;
  const char * iftmp.52;
  int D.20250;
  unsigned int D.20251;
  unsigned int D.20252;
  unsigned int D.20253;
  int num_major_sections;
  char full_timing_buff[1024];

  try
    {
      D.20199 = major_collector.get_num_major_sections;
      num_major_sections = D.20199 ();
      full_timing_buff[0] = 0;
      D.20200 = info->is_overflow;
      if (D.20200 == 0) goto <D.20201>; else goto <D.20202>;
      <D.20201>:
      D.20203 = info->stw_time;
      D.20204 = (float) D.20203;
      D.20205 = D.20204 / 1.0e+3;
      D.20206 = (double) D.20205;
      D.20207 = info->bridge_time;
      D.20208 = (int) D.20207;
      D.20209 = (float) D.20208;
      D.20210 = D.20209 / 1.0e+3;
      D.20211 = (double) D.20210;
      sprintf (&full_timing_buff, "total %.2fms, bridge %.2fms", D.20206, D.20211);
      <D.20202>:
      D.20212 = info->generation;
      if (D.20212 == 1) goto <D.20213>; else goto <D.20214>;
      <D.20213>:
      D.20200 = info->is_overflow;
      if (D.20200 != 0) goto <D.20216>; else goto <D.20217>;
      <D.20216>:
      iftmp.44 = "_OVERFLOW";
      goto <D.20218>;
      <D.20217>:
      iftmp.44 = "";
      <D.20218>:
      D.20220 = info->reason;
      if (D.20220 != 0B) goto <D.20221>; else goto <D.20222>;
      <D.20221>:
      iftmp.45 = info->reason;
      goto <D.20223>;
      <D.20222>:
      iftmp.45 = "";
      <D.20223>:
      D.20224 = info->total_time;
      D.20225 = (int) D.20224;
      D.20226 = (float) D.20225;
      D.20227 = D.20226 / 1.0e+3;
      D.20228 = (double) D.20227;
      D.20229 = major_collector.section_size;
      num_major_sections.46 = (unsigned int) num_major_sections;
      D.20231 = D.20229 * num_major_sections.46;
      D.20232 = D.20231 / 1024;
      D.20229 = 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.20235 = D.20229 * last_major_num_sections.48;
      D.20236 = D.20235 / 1024;
      los_memory_usage.49 = los_memory_usage;
      D.20238 = los_memory_usage.49 / 1024;
      last_los_memory_usage.50 = last_los_memory_usage;
      D.20240 = 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.20228, &full_timing_buff, D.20232, D.20236, D.20238, D.20240);
      goto <D.20241>;
      <D.20214>:
      D.20200 = info->is_overflow;
      if (D.20200 != 0) goto <D.20243>; else goto <D.20244>;
      <D.20243>:
      iftmp.51 = "_OVERFLOW";
      goto <D.20245>;
      <D.20244>:
      iftmp.51 = "";
      <D.20245>:
      D.20220 = info->reason;
      if (D.20220 != 0B) goto <D.20247>; else goto <D.20248>;
      <D.20247>:
      iftmp.52 = info->reason;
      goto <D.20249>;
      <D.20248>:
      iftmp.52 = "";
      <D.20249>:
      D.20224 = info->total_time;
      D.20225 = (int) D.20224;
      D.20226 = (float) D.20225;
      D.20227 = D.20226 / 1.0e+3;
      D.20228 = (double) D.20227;
      last_major_num_sections.47 = last_major_num_sections;
      D.20250 = num_major_sections - last_major_num_sections.47;
      D.20251 = (unsigned int) D.20250;
      D.20229 = major_collector.section_size;
      D.20252 = D.20251 * D.20229;
      D.20253 = D.20252 / 1024;
      D.20229 = major_collector.section_size;
      num_major_sections.46 = (unsigned int) num_major_sections;
      D.20231 = D.20229 * num_major_sections.46;
      D.20232 = D.20231 / 1024;
      los_memory_usage.49 = los_memory_usage;
      D.20238 = 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.20228, &full_timing_buff, D.20253, D.20232, D.20238);
      <D.20241>:
    }
  finally
    {
      full_timing_buff = {CLOBBER};
    }
}


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

  D.20255 = __builtin_object_size (__s, 1);
  D.20254 = __builtin___sprintf_chk (__s, 1, D.20255, __fmt, __builtin_va_arg_pack ());
  return D.20254;
}


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

  D.20259 = minor_collection_allowance;
  return D.20259;
}


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

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

  D.20264 = ptr != 0B;
  D.20265 = assert_description == 0B;
  D.20266 = D.20264 | D.20265;
  if (D.20266 != 0) goto <D.20267>; else goto <D.20268>;
  <D.20267>:
  return;
  <D.20268>:
  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.20271;
  _Bool D.20272;
  long int D.20273;
  long int D.20274;
  int flags.58;
  int D.20278;
  long unsigned int D.20279;
  int D.20280;
  unsigned int D.20283;
  void * D.20284;
  void * __old_x.59;
  void * D.20286;
  unsigned int D.20287;
  void * D.20290;
  void * ptr;

  D.20271 = flags & 4294967292;
  D.20272 = D.20271 != 0;
  D.20273 = (long int) D.20272;
  D.20274 = __builtin_expect (D.20273, 0);
  if (D.20274 != 0) goto <D.20275>; else goto <D.20276>;
  <D.20275>:
  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.20276>:
  flags.58 = (int) flags;
  D.20278 = flags.58 & 2;
  D.20279 = prot_flags_for_activate (D.20278);
  D.20280 = (int) D.20279;
  ptr = mono_valloc (0B, size, D.20280);
  sgen_assert_memory_alloc (ptr, size, assert_description);
  if (ptr != 0B) goto <D.20281>; else goto <D.20282>;
  <D.20281>:
  {
    size_t __old_x;

    <D.20013>:
    __old_x = total_alloc;
    D.20283 = __old_x + size;
    D.20284 = (void *) D.20283;
    __old_x.59 = (void *) __old_x;
    D.20286 = InterlockedCompareExchangePointer (&total_alloc, D.20284, __old_x.59);
    __old_x.59 = (void *) __old_x;
    if (D.20286 != __old_x.59) goto <D.20013>; else goto <D.20014>;
    <D.20014>:
  }
  D.20287 = flags & 1;
  if (D.20287 != 0) goto <D.20288>; else goto <D.20289>;
  <D.20288>:
  <D.20289>:
  <D.20282>:
  D.20290 = ptr;
  return D.20290;
}


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

  if (activate != 0) goto <D.20293>; else goto <D.20294>;
  <D.20293>:
  iftmp.60 = 3;
  goto <D.20295>;
  <D.20294>:
  iftmp.60 = 0;
  <D.20295>:
  prot_flags = iftmp.60;
  D.20296 = prot_flags | 80;
  return D.20296;
}


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

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


sgen_alloc_os_memory_aligned (size_t size, mword alignment, SgenAllocFlags flags, const char * assert_description)
{
  unsigned int D.20303;
  _Bool D.20304;
  long int D.20305;
  long int D.20306;
  int flags.63;
  int D.20310;
  long unsigned int D.20311;
  int D.20312;
  unsigned int D.20315;
  void * D.20316;
  void * __old_x.64;
  void * D.20318;
  unsigned int D.20319;
  void * D.20322;
  void * ptr;

  D.20303 = flags & 4294967292;
  D.20304 = D.20303 != 0;
  D.20305 = (long int) D.20304;
  D.20306 = __builtin_expect (D.20305, 0);
  if (D.20306 != 0) goto <D.20307>; else goto <D.20308>;
  <D.20307>:
  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.20308>:
  flags.63 = (int) flags;
  D.20310 = flags.63 & 2;
  D.20311 = prot_flags_for_activate (D.20310);
  D.20312 = (int) D.20311;
  ptr = mono_valloc_aligned (size, alignment, D.20312);
  sgen_assert_memory_alloc (ptr, size, assert_description);
  if (ptr != 0B) goto <D.20313>; else goto <D.20314>;
  <D.20313>:
  {
    size_t __old_x;

    <D.20023>:
    __old_x = total_alloc;
    D.20315 = __old_x + size;
    D.20316 = (void *) D.20315;
    __old_x.64 = (void *) __old_x;
    D.20318 = InterlockedCompareExchangePointer (&total_alloc, D.20316, __old_x.64);
    __old_x.64 = (void *) __old_x;
    if (D.20318 != __old_x.64) goto <D.20023>; else goto <D.20024>;
    <D.20024>:
  }
  D.20319 = flags & 1;
  if (D.20319 != 0) goto <D.20320>; else goto <D.20321>;
  <D.20320>:
  <D.20321>:
  <D.20314>:
  D.20322 = ptr;
  return D.20322;
}


sgen_free_os_memory (void * addr, size_t size, SgenAllocFlags flags)
{
  unsigned int D.20324;
  _Bool D.20325;
  long int D.20326;
  long int D.20327;
  unsigned int D.20330;
  void * D.20331;
  void * __old_x.65;
  void * D.20333;
  unsigned int D.20334;

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

    <D.20031>:
    __old_x = total_alloc;
    D.20330 = __old_x - size;
    D.20331 = (void *) D.20330;
    __old_x.65 = (void *) __old_x;
    D.20333 = InterlockedCompareExchangePointer (&total_alloc, D.20331, __old_x.65);
    __old_x.65 = (void *) __old_x;
    if (D.20333 != __old_x.65) goto <D.20031>; else goto <D.20032>;
    <D.20032>:
  }
  D.20334 = flags & 1;
  if (D.20334 != 0) goto <D.20335>; else goto <D.20336>;
  <D.20335>:
  <D.20336>:
}


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

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


sgen_memgov_release_space (mword size, int space)
{
  unsigned int D.20340;
  void * D.20341;
  void * __old_x.67;
  void * D.20343;

  {
    size_t __old_x;

    <D.20044>:
    __old_x = allocated_heap;
    D.20340 = __old_x - size;
    D.20341 = (void *) D.20340;
    __old_x.67 = (void *) __old_x;
    D.20343 = InterlockedCompareExchangePointer (&allocated_heap, D.20341, __old_x.67);
    __old_x.67 = (void *) __old_x;
    if (D.20343 != __old_x.67) goto <D.20044>; else goto <D.20045>;
    <D.20045>:
  }
}


sgen_memgov_try_alloc_space (mword size, int space)
{
  unsigned int D.20344;
  gboolean D.20347;
  unsigned int D.20348;
  void * D.20349;
  void * __old_x.68;
  void * D.20351;
  unsigned int allocated_heap.69;

  D.20344 = sgen_memgov_available_free_space ();
  if (D.20344 < size) goto <D.20345>; else goto <D.20346>;
  <D.20345>:
  D.20347 = 0;
  return D.20347;
  <D.20346>:
  {
    size_t __old_x;

    <D.20051>:
    __old_x = allocated_heap;
    D.20348 = __old_x + size;
    D.20349 = (void *) D.20348;
    __old_x.68 = (void *) __old_x;
    D.20351 = InterlockedCompareExchangePointer (&allocated_heap, D.20349, __old_x.68);
    __old_x.68 = (void *) __old_x;
    if (D.20351 != __old_x.68) goto <D.20051>; else goto <D.20052>;
    <D.20052>:
  }
  allocated_heap.69 = allocated_heap;
  mono_runtime_resource_check_limit (2, allocated_heap.69);
  D.20347 = 1;
  return D.20347;
}


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.20362;
  long int D.20365;
  unsigned int max_heap_size.72;
  double D.20367;
  double default_allowance_nursery_size_ratio.73;
  double D.20369;
  unsigned int minor_collection_allowance.74;

  if (soft_limit != 0) goto <D.20354>; else goto <D.20355>;
  <D.20354>:
  soft_limit.70 = (unsigned int) soft_limit;
  soft_heap_limit = soft_limit.70;
  <D.20355>:
  debug_print_allowance = debug_allowance;
  if (max_heap == 0) goto <D.20357>; else goto <D.20358>;
  <D.20357>:
  return;
  <D.20358>:
  if (max_heap < soft_limit) goto <D.20359>; else goto <D.20360>;
  <D.20359>:
  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.20360>:
  sgen_nursery_size.71 = sgen_nursery_size;
  D.20362 = sgen_nursery_size.71 * 4;
  if (D.20362 > max_heap) goto <D.20363>; else goto <D.20364>;
  <D.20363>:
  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.20364>:
  sgen_nursery_size.71 = sgen_nursery_size;
  D.20365 = max_heap - sgen_nursery_size.71;
  max_heap_size.72 = (unsigned int) D.20365;
  max_heap_size = max_heap_size.72;
  sgen_nursery_size.71 = sgen_nursery_size;
  D.20367 = (double) sgen_nursery_size.71;
  default_allowance_nursery_size_ratio.73 = default_allowance_nursery_size_ratio;
  D.20369 = D.20367 * default_allowance_nursery_size_ratio.73;
  minor_collection_allowance.74 = (unsigned int) D.20369;
  minor_collection_allowance = minor_collection_allowance.74;
  if (allowance_ratio != 0.0) goto <D.20371>; else goto <D.20372>;
  <D.20371>:
  default_allowance_nursery_size_ratio = allowance_ratio;
  <D.20372>:
  if (save_target != 0.0) goto <D.20373>; else goto <D.20374>;
  <D.20373>:
  save_target_ratio = save_target;
  <D.20374>:
}