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.7338;
  int set_mask.2;
  int set_mask.3;
  struct MonoCounter * counters.4;
  struct MonoCounter * D.7348;
  struct MonoCounter * counter;

  valid_mask.1 = valid_mask;
  D.7338 = type & valid_mask.1;
  if (D.7338 == 0) goto <D.7339>; else goto <D.7340>;
  <D.7339>:
  return;
  <D.7340>:
  counter = malloc (16);
  if (counter == 0B) goto <D.7341>; else goto <D.7342>;
  <D.7341>:
  return;
  <D.7342>:
  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.7346>; else goto <D.7347>;
  <D.7346>:
  {
    struct MonoCounter * item;

    item = counters;
    goto <D.7257>;
    <D.7256>:
    item = item->next;
    <D.7257>:
    D.7348 = item->next;
    if (D.7348 != 0B) goto <D.7256>; else goto <D.7258>;
    <D.7258>:
    item->next = counter;
  }
  goto <D.7349>;
  <D.7347>:
  counters = counter;
  <D.7349>:
}


mono_counters_dump (int section_mask, struct FILE * outfile)
{
  int valid_mask.5;
  struct MonoCounter * counters.6;
  int D.7355;
  int set_mask.7;
  int D.7359;
  const char[10] * D.7362;
  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.7353>; else goto <D.7354>;
  <D.7353>:
  return;
  <D.7354>:
  j = 0;
  i = 256;
  goto <D.7309>;
  <D.7308>:
  D.7355 = section_mask & i;
  if (D.7355 != 0) goto <D.7356>; else goto <D.7357>;
  <D.7356>:
  set_mask.7 = set_mask;
  D.7359 = set_mask.7 & i;
  if (D.7359 != 0) goto <D.7360>; else goto <D.7361>;
  <D.7360>:
  D.7362 = &section_names[j];
  fprintf (outfile, "\n%s statistics\n", D.7362);
  mono_counters_dump_section (i, outfile);
  <D.7361>:
  <D.7357>:
  j = j + 1;
  i = i << 1;
  <D.7309>:
  if (i <= 4096) goto <D.7308>; else goto <D.7310>;
  <D.7310>:
  fflush (outfile);
}


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

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


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

  counter = counters;
  goto <D.7300>;
  <D.7299>:
  D.7366 = counter->type;
  D.7367 = D.7366 & section;
  if (D.7367 != 0) goto <D.7368>; else goto <D.7369>;
  <D.7368>:
  dump_counter (counter, outfile);
  <D.7369>:
  counter = counter->next;
  <D.7300>:
  if (counter != 0B) goto <D.7299>; else goto <D.7301>;
  <D.7301>:
}


dump_counter (struct MonoCounter * counter, struct FILE * outfile)
{
  int D.7370;
  int D.7371;
  int D.7372;
  void * D.7375;
  int (*<T1416>) (void) D.7376;
  const char * D.7378;
  guint (*<T1893>) (void) D.7381;
  gint64 (*<T1898>) (void) D.7385;
  guint64 (*<T189d>) (void) D.7389;
  gssize (*<T18a2>) (void) D.7393;
  double (*<T18a5>) (void) D.7397;
  char * (*<T18a8>) (void) D.7401;
  double D.7406;
  double D.7407;
  int intval;
  guint uintval;
  gint64 int64val;
  guint64 uint64val;
  gssize wordval;
  double dval;
  const char * str;

  D.7370 = counter->type;
  D.7371 = D.7370 & 15;
  switch (D.7371) <default: <D.7408>, case 0: <D.7284>, case 1: <D.7286>, case 2: <D.7289>, case 3: <D.7287>, case 4: <D.7288>, case 5: <D.7290>, case 6: <D.7291>, case 7: <D.7292>>
  <D.7284>:
  D.7370 = counter->type;
  D.7372 = D.7370 & 128;
  if (D.7372 != 0) goto <D.7373>; else goto <D.7374>;
  <D.7373>:
  D.7375 = counter->addr;
  D.7376 = (int (*<T1416>) (void)) D.7375;
  intval = D.7376 ();
  goto <D.7377>;
  <D.7374>:
  D.7375 = counter->addr;
  intval = MEM[(int *)D.7375];
  <D.7377>:
  D.7378 = counter->name;
  fprintf (outfile, "%-36s: %d\n", D.7378, intval);
  goto <D.7285>;
  <D.7286>:
  D.7370 = counter->type;
  D.7372 = D.7370 & 128;
  if (D.7372 != 0) goto <D.7379>; else goto <D.7380>;
  <D.7379>:
  D.7375 = counter->addr;
  D.7381 = (guint (*<T1893>) (void)) D.7375;
  uintval = D.7381 ();
  goto <D.7382>;
  <D.7380>:
  D.7375 = counter->addr;
  uintval = MEM[(guint *)D.7375];
  <D.7382>:
  D.7378 = counter->name;
  fprintf (outfile, "%-36s: %u\n", D.7378, uintval);
  goto <D.7285>;
  <D.7287>:
  D.7370 = counter->type;
  D.7372 = D.7370 & 128;
  if (D.7372 != 0) goto <D.7383>; else goto <D.7384>;
  <D.7383>:
  D.7375 = counter->addr;
  D.7385 = (gint64 (*<T1898>) (void)) D.7375;
  int64val = D.7385 ();
  goto <D.7386>;
  <D.7384>:
  D.7375 = counter->addr;
  int64val = MEM[(gint64 *)D.7375];
  <D.7386>:
  D.7378 = counter->name;
  fprintf (outfile, "%-36s: %lld\n", D.7378, int64val);
  goto <D.7285>;
  <D.7288>:
  D.7370 = counter->type;
  D.7372 = D.7370 & 128;
  if (D.7372 != 0) goto <D.7387>; else goto <D.7388>;
  <D.7387>:
  D.7375 = counter->addr;
  D.7389 = (guint64 (*<T189d>) (void)) D.7375;
  uint64val = D.7389 ();
  goto <D.7390>;
  <D.7388>:
  D.7375 = counter->addr;
  uint64val = MEM[(guint64 *)D.7375];
  <D.7390>:
  D.7378 = counter->name;
  fprintf (outfile, "%-36s: %llu\n", D.7378, uint64val);
  goto <D.7285>;
  <D.7289>:
  D.7370 = counter->type;
  D.7372 = D.7370 & 128;
  if (D.7372 != 0) goto <D.7391>; else goto <D.7392>;
  <D.7391>:
  D.7375 = counter->addr;
  D.7393 = (gssize (*<T18a2>) (void)) D.7375;
  wordval = D.7393 ();
  goto <D.7394>;
  <D.7392>:
  D.7375 = counter->addr;
  wordval = MEM[(gssize *)D.7375];
  <D.7394>:
  D.7378 = counter->name;
  fprintf (outfile, "%-36s: %d\n", D.7378, wordval);
  goto <D.7285>;
  <D.7290>:
  D.7370 = counter->type;
  D.7372 = D.7370 & 128;
  if (D.7372 != 0) goto <D.7395>; else goto <D.7396>;
  <D.7395>:
  D.7375 = counter->addr;
  D.7397 = (double (*<T18a5>) (void)) D.7375;
  dval = D.7397 ();
  goto <D.7398>;
  <D.7396>:
  D.7375 = counter->addr;
  dval = MEM[(double *)D.7375];
  <D.7398>:
  D.7378 = counter->name;
  fprintf (outfile, "%-36s: %.4f\n", D.7378, dval);
  goto <D.7285>;
  <D.7291>:
  D.7370 = counter->type;
  D.7372 = D.7370 & 128;
  if (D.7372 != 0) goto <D.7399>; else goto <D.7400>;
  <D.7399>:
  D.7375 = counter->addr;
  D.7401 = (char * (*<T18a8>) (void)) D.7375;
  str = D.7401 ();
  goto <D.7402>;
  <D.7400>:
  D.7375 = counter->addr;
  str = MEM[(char * *)D.7375];
  <D.7402>:
  D.7378 = counter->name;
  fprintf (outfile, "%-36s: %s\n", D.7378, str);
  goto <D.7285>;
  <D.7292>:
  D.7370 = counter->type;
  D.7372 = D.7370 & 128;
  if (D.7372 != 0) goto <D.7403>; else goto <D.7404>;
  <D.7403>:
  D.7375 = counter->addr;
  D.7385 = (gint64 (*<T1898>) (void)) D.7375;
  int64val = D.7385 ();
  goto <D.7405>;
  <D.7404>:
  D.7375 = counter->addr;
  int64val = MEM[(gint64 *)D.7375];
  <D.7405>:
  D.7378 = counter->name;
  D.7406 = (double) int64val;
  D.7407 = D.7406 / 1.0e+3;
  fprintf (outfile, "%-36s: %.2f ms\n", D.7378, D.7407);
  goto <D.7285>;
  <D.7408>:
  <D.7285>:
}


mono_counters_cleanup ()
{
  struct MonoCounter * counter;

  counter = counters;
  goto <D.7317>;
  <D.7316>:
  {
    struct MonoCounter * tmp;

    tmp = counters;
    counter = counter->next;
    free (tmp);
  }
  <D.7317>:
  if (counter != 0B) goto <D.7316>; else goto <D.7318>;
  <D.7318>:
  counters = 0B;
}


mono_runtime_resource_check_limit (int resource_type, uintptr_t value)
{
  void (*<T1880>) (int, uintptr_t, int) limit_reached.8;
  int D.7412;
  int D.7413;
  unsigned int D.7414;
  unsigned int D.7417;

  limit_reached.8 = limit_reached;
  if (limit_reached.8 == 0B) goto <D.7410>; else goto <D.7411>;
  <D.7410>:
  return;
  <D.7411>:
  D.7412 = resource_type * 2;
  D.7413 = D.7412 + 1;
  D.7414 = resource_limits[D.7413];
  if (D.7414 < value) goto <D.7415>; else goto <D.7416>;
  <D.7415>:
  limit_reached.8 = limit_reached;
  limit_reached.8 (resource_type, value, 0);
  return;
  <D.7416>:
  D.7412 = resource_type * 2;
  D.7417 = resource_limits[D.7412];
  if (D.7417 < value) goto <D.7418>; else goto <D.7419>;
  <D.7418>:
  limit_reached.8 = limit_reached;
  limit_reached.8 (resource_type, value, 1);
  <D.7419>:
}


mono_runtime_resource_limit (int resource_type, uintptr_t soft_limit, uintptr_t hard_limit)
{
  unsigned int resource_type.9;
  int D.7424;
  int D.7427;
  int D.7428;

  resource_type.9 = (unsigned int) resource_type;
  if (resource_type.9 > 2) goto <D.7422>; else goto <D.7423>;
  <D.7422>:
  D.7424 = 0;
  return D.7424;
  <D.7423>:
  if (soft_limit > hard_limit) goto <D.7425>; else goto <D.7426>;
  <D.7425>:
  D.7424 = 0;
  return D.7424;
  <D.7426>:
  D.7427 = resource_type * 2;
  resource_limits[D.7427] = soft_limit;
  D.7427 = resource_type * 2;
  D.7428 = D.7427 + 1;
  resource_limits[D.7428] = hard_limit;
  D.7424 = 1;
  return D.7424;
}


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