mono_counters_enable (int section_mask)
{
  int valid_mask.0;

  valid_mask.0 = section_mask & -256;
  valid_mask = valid_mask.0;
}


mono_counters_register (const char * name, int type, void * addr)
{
  int valid_mask.1;
  int D.5593;
  int set_mask.2;
  int set_mask.3;
  struct MonoCounter * counters.4;
  struct MonoCounter * D.5603;
  struct MonoCounter * counter;

  valid_mask.1 = valid_mask;
  D.5593 = type & valid_mask.1;
  if (D.5593 == 0) goto <D.5594>; else goto <D.5595>;
  <D.5594>:
  return;
  <D.5595>:
  counter = malloc (32);
  if (counter == 0B) goto <D.5596>; else goto <D.5597>;
  <D.5596>:
  return;
  <D.5597>:
  counter->name = name;
  counter->type = type;
  counter->addr = addr;
  counter->next = 0B;
  set_mask.2 = set_mask;
  set_mask.3 = set_mask.2 | type;
  set_mask = set_mask.3;
  counters.4 = counters;
  if (counters.4 != 0B) goto <D.5601>; else goto <D.5602>;
  <D.5601>:
  {
    struct MonoCounter * item;

    item = counters;
    goto <D.5514>;
    <D.5513>:
    item = item->next;
    <D.5514>:
    D.5603 = item->next;
    if (D.5603 != 0B) goto <D.5513>; else goto <D.5515>;
    <D.5515>:
    item->next = counter;
  }
  goto <D.5604>;
  <D.5602>:
  counters = counter;
  <D.5604>:
}


mono_counters_dump (int section_mask, struct FILE * outfile)
{
  int valid_mask.5;
  struct MonoCounter * counters.6;
  int D.5610;
  int set_mask.7;
  int D.5614;
  const char[10] * D.5617;
  int i;
  int j;

  valid_mask.5 = valid_mask;
  section_mask = section_mask & valid_mask.5;
  counters.6 = counters;
  if (counters.6 == 0B) goto <D.5608>; else goto <D.5609>;
  <D.5608>:
  return;
  <D.5609>:
  j = 0;
  i = 256;
  goto <D.5566>;
  <D.5565>:
  D.5610 = section_mask & i;
  if (D.5610 != 0) goto <D.5611>; else goto <D.5612>;
  <D.5611>:
  set_mask.7 = set_mask;
  D.5614 = set_mask.7 & i;
  if (D.5614 != 0) goto <D.5615>; else goto <D.5616>;
  <D.5615>:
  D.5617 = &section_names[j];
  fprintf (outfile, "\n%s statistics\n", D.5617);
  mono_counters_dump_section (i, outfile);
  <D.5616>:
  <D.5612>:
  j = j + 1;
  i = i << 1;
  <D.5566>:
  if (i <= 4096) goto <D.5565>; else goto <D.5567>;
  <D.5567>:
  fflush (outfile);
}


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

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


mono_counters_dump_section (int section, struct FILE * outfile)
{
  int D.5621;
  int D.5622;
  struct MonoCounter * counter;

  counter = counters;
  goto <D.5557>;
  <D.5556>:
  D.5621 = counter->type;
  D.5622 = D.5621 & section;
  if (D.5622 != 0) goto <D.5623>; else goto <D.5624>;
  <D.5623>:
  dump_counter (counter, outfile);
  <D.5624>:
  counter = counter->next;
  <D.5557>:
  if (counter != 0B) goto <D.5556>; else goto <D.5558>;
  <D.5558>:
}


dump_counter (struct MonoCounter * counter, struct FILE * outfile)
{
  int D.5625;
  int D.5626;
  int D.5627;
  void * D.5630;
  int (*<Ta5f>) (void) D.5631;
  const char * D.5633;
  guint (*<Tede>) (void) D.5636;
  gint64 (*<Tee3>) (void) D.5640;
  guint64 (*<Tee8>) (void) D.5644;
  gssize (*<Teed>) (void) D.5648;
  int D.5650;
  double (*<Tef0>) (void) D.5653;
  char * (*<Tef3>) (void) D.5657;
  double D.5662;
  double D.5663;
  int intval;
  guint uintval;
  gint64 int64val;
  guint64 uint64val;
  gssize wordval;
  double dval;
  const char * str;

  D.5625 = counter->type;
  D.5626 = D.5625 & 15;
  switch (D.5626) <default: <D.5664>, case 0: <D.5541>, case 1: <D.5543>, case 2: <D.5546>, case 3: <D.5544>, case 4: <D.5545>, case 5: <D.5547>, case 6: <D.5548>, case 7: <D.5549>>
  <D.5541>:
  D.5625 = counter->type;
  D.5627 = D.5625 & 128;
  if (D.5627 != 0) goto <D.5628>; else goto <D.5629>;
  <D.5628>:
  D.5630 = counter->addr;
  D.5631 = (int (*<Ta5f>) (void)) D.5630;
  intval = D.5631 ();
  goto <D.5632>;
  <D.5629>:
  D.5630 = counter->addr;
  intval = MEM[(int *)D.5630];
  <D.5632>:
  D.5633 = counter->name;
  fprintf (outfile, "%-36s: %d\n", D.5633, intval);
  goto <D.5542>;
  <D.5543>:
  D.5625 = counter->type;
  D.5627 = D.5625 & 128;
  if (D.5627 != 0) goto <D.5634>; else goto <D.5635>;
  <D.5634>:
  D.5630 = counter->addr;
  D.5636 = (guint (*<Tede>) (void)) D.5630;
  uintval = D.5636 ();
  goto <D.5637>;
  <D.5635>:
  D.5630 = counter->addr;
  uintval = MEM[(guint *)D.5630];
  <D.5637>:
  D.5633 = counter->name;
  fprintf (outfile, "%-36s: %u\n", D.5633, uintval);
  goto <D.5542>;
  <D.5544>:
  D.5625 = counter->type;
  D.5627 = D.5625 & 128;
  if (D.5627 != 0) goto <D.5638>; else goto <D.5639>;
  <D.5638>:
  D.5630 = counter->addr;
  D.5640 = (gint64 (*<Tee3>) (void)) D.5630;
  int64val = D.5640 ();
  goto <D.5641>;
  <D.5639>:
  D.5630 = counter->addr;
  int64val = MEM[(gint64 *)D.5630];
  <D.5641>:
  D.5633 = counter->name;
  fprintf (outfile, "%-36s: %lld\n", D.5633, int64val);
  goto <D.5542>;
  <D.5545>:
  D.5625 = counter->type;
  D.5627 = D.5625 & 128;
  if (D.5627 != 0) goto <D.5642>; else goto <D.5643>;
  <D.5642>:
  D.5630 = counter->addr;
  D.5644 = (guint64 (*<Tee8>) (void)) D.5630;
  uint64val = D.5644 ();
  goto <D.5645>;
  <D.5643>:
  D.5630 = counter->addr;
  uint64val = MEM[(guint64 *)D.5630];
  <D.5645>:
  D.5633 = counter->name;
  fprintf (outfile, "%-36s: %llu\n", D.5633, uint64val);
  goto <D.5542>;
  <D.5546>:
  D.5625 = counter->type;
  D.5627 = D.5625 & 128;
  if (D.5627 != 0) goto <D.5646>; else goto <D.5647>;
  <D.5646>:
  D.5630 = counter->addr;
  D.5648 = (gssize (*<Teed>) (void)) D.5630;
  wordval = D.5648 ();
  goto <D.5649>;
  <D.5647>:
  D.5630 = counter->addr;
  wordval = MEM[(gssize *)D.5630];
  <D.5649>:
  D.5633 = counter->name;
  D.5650 = (int) wordval;
  fprintf (outfile, "%-36s: %d\n", D.5633, D.5650);
  goto <D.5542>;
  <D.5547>:
  D.5625 = counter->type;
  D.5627 = D.5625 & 128;
  if (D.5627 != 0) goto <D.5651>; else goto <D.5652>;
  <D.5651>:
  D.5630 = counter->addr;
  D.5653 = (double (*<Tef0>) (void)) D.5630;
  dval = D.5653 ();
  goto <D.5654>;
  <D.5652>:
  D.5630 = counter->addr;
  dval = MEM[(double *)D.5630];
  <D.5654>:
  D.5633 = counter->name;
  fprintf (outfile, "%-36s: %.4f\n", D.5633, dval);
  goto <D.5542>;
  <D.5548>:
  D.5625 = counter->type;
  D.5627 = D.5625 & 128;
  if (D.5627 != 0) goto <D.5655>; else goto <D.5656>;
  <D.5655>:
  D.5630 = counter->addr;
  D.5657 = (char * (*<Tef3>) (void)) D.5630;
  str = D.5657 ();
  goto <D.5658>;
  <D.5656>:
  D.5630 = counter->addr;
  str = MEM[(char * *)D.5630];
  <D.5658>:
  D.5633 = counter->name;
  fprintf (outfile, "%-36s: %s\n", D.5633, str);
  goto <D.5542>;
  <D.5549>:
  D.5625 = counter->type;
  D.5627 = D.5625 & 128;
  if (D.5627 != 0) goto <D.5659>; else goto <D.5660>;
  <D.5659>:
  D.5630 = counter->addr;
  D.5640 = (gint64 (*<Tee3>) (void)) D.5630;
  int64val = D.5640 ();
  goto <D.5661>;
  <D.5660>:
  D.5630 = counter->addr;
  int64val = MEM[(gint64 *)D.5630];
  <D.5661>:
  D.5633 = counter->name;
  D.5662 = (double) int64val;
  D.5663 = D.5662 / 1.0e+3;
  fprintf (outfile, "%-36s: %.2f ms\n", D.5633, D.5663);
  goto <D.5542>;
  <D.5664>:
  <D.5542>:
}


mono_counters_cleanup ()
{
  struct MonoCounter * counter;

  counter = counters;
  goto <D.5574>;
  <D.5573>:
  {
    struct MonoCounter * tmp;

    tmp = counters;
    counter = counter->next;
    free (tmp);
  }
  <D.5574>:
  if (counter != 0B) goto <D.5573>; else goto <D.5575>;
  <D.5575>:
  counters = 0B;
}


mono_runtime_resource_check_limit (int resource_type, uintptr_t value)
{
  void (*<Tecb>) (int, uintptr_t, int) limit_reached.8;
  int D.5668;
  int D.5669;
  long unsigned int D.5670;
  long unsigned int D.5673;

  limit_reached.8 = limit_reached;
  if (limit_reached.8 == 0B) goto <D.5666>; else goto <D.5667>;
  <D.5666>:
  return;
  <D.5667>:
  D.5668 = resource_type * 2;
  D.5669 = D.5668 + 1;
  D.5670 = resource_limits[D.5669];
  if (D.5670 < value) goto <D.5671>; else goto <D.5672>;
  <D.5671>:
  limit_reached.8 = limit_reached;
  limit_reached.8 (resource_type, value, 0);
  return;
  <D.5672>:
  D.5668 = resource_type * 2;
  D.5673 = resource_limits[D.5668];
  if (D.5673 < value) goto <D.5674>; else goto <D.5675>;
  <D.5674>:
  limit_reached.8 = limit_reached;
  limit_reached.8 (resource_type, value, 1);
  <D.5675>:
}


mono_runtime_resource_limit (int resource_type, uintptr_t soft_limit, uintptr_t hard_limit)
{
  unsigned int resource_type.9;
  int D.5680;
  int D.5683;
  int D.5684;

  resource_type.9 = (unsigned int) resource_type;
  if (resource_type.9 > 2) goto <D.5678>; else goto <D.5679>;
  <D.5678>:
  D.5680 = 0;
  return D.5680;
  <D.5679>:
  if (soft_limit > hard_limit) goto <D.5681>; else goto <D.5682>;
  <D.5681>:
  D.5680 = 0;
  return D.5680;
  <D.5682>:
  D.5683 = resource_type * 2;
  resource_limits[D.5683] = soft_limit;
  D.5683 = resource_type * 2;
  D.5684 = D.5683 + 1;
  resource_limits[D.5684] = hard_limit;
  D.5680 = 1;
  return D.5680;
}


mono_runtime_resource_set_callback (void (*MonoResourceCallback) (int, uintptr_t, int) callback)
{
  limit_reached = callback;
}