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

  valid_mask.1 = valid_mask;
  D.4749 = type & valid_mask.1;
  if (D.4749 == 0) goto <D.4750>; else goto <D.4751>;
  <D.4750>:
  return;
  <D.4751>:
  counter = malloc (16);
  if (counter == 0B) goto <D.4752>; else goto <D.4753>;
  <D.4752>:
  return;
  <D.4753>:
  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.4757>; else goto <D.4758>;
  <D.4757>:
  {
    struct MonoCounter * item;

    item = counters;
    goto <D.4670>;
    <D.4669>:
    item = item->next;
    <D.4670>:
    D.4759 = item->next;
    if (D.4759 != 0B) goto <D.4669>; else goto <D.4671>;
    <D.4671>:
    item->next = counter;
  }
  goto <D.4760>;
  <D.4758>:
  counters = counter;
  <D.4760>:
}


mono_counters_dump (int section_mask, struct FILE * outfile)
{
  int valid_mask.5;
  struct MonoCounter * counters.6;
  int D.4766;
  int set_mask.7;
  int D.4770;
  const char[10] * D.4773;
  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.4764>; else goto <D.4765>;
  <D.4764>:
  return;
  <D.4765>:
  j = 0;
  i = 256;
  goto <D.4722>;
  <D.4721>:
  D.4766 = section_mask & i;
  if (D.4766 != 0) goto <D.4767>; else goto <D.4768>;
  <D.4767>:
  set_mask.7 = set_mask;
  D.4770 = set_mask.7 & i;
  if (D.4770 != 0) goto <D.4771>; else goto <D.4772>;
  <D.4771>:
  D.4773 = &section_names[j];
  fprintf (outfile, "\n%s statistics\n", D.4773);
  mono_counters_dump_section (i, outfile);
  <D.4772>:
  <D.4768>:
  j = j + 1;
  i = i << 1;
  <D.4722>:
  if (i <= 4096) goto <D.4721>; else goto <D.4723>;
  <D.4723>:
  fflush (outfile);
}


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

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


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

  counter = counters;
  goto <D.4713>;
  <D.4712>:
  D.4777 = counter->type;
  D.4778 = D.4777 & section;
  if (D.4778 != 0) goto <D.4779>; else goto <D.4780>;
  <D.4779>:
  dump_counter (counter, outfile);
  <D.4780>:
  counter = counter->next;
  <D.4713>:
  if (counter != 0B) goto <D.4712>; else goto <D.4714>;
  <D.4714>:
}


dump_counter (struct MonoCounter * counter, struct FILE * outfile)
{
  int D.4781;
  int D.4782;
  int D.4783;
  void * D.4786;
  int (*<T987>) (void) D.4787;
  const char * D.4789;
  guint (*<Te05>) (void) D.4792;
  gint64 (*<Te0a>) (void) D.4796;
  guint64 (*<Te0f>) (void) D.4800;
  gssize (*<Te14>) (void) D.4804;
  double (*<Te17>) (void) D.4808;
  char * (*<Te1a>) (void) D.4812;
  double D.4817;
  double D.4818;
  int intval;
  guint uintval;
  gint64 int64val;
  guint64 uint64val;
  gssize wordval;
  double dval;
  const char * str;

  D.4781 = counter->type;
  D.4782 = D.4781 & 15;
  switch (D.4782) <default: <D.4819>, case 0: <D.4697>, case 1: <D.4699>, case 2: <D.4702>, case 3: <D.4700>, case 4: <D.4701>, case 5: <D.4703>, case 6: <D.4704>, case 7: <D.4705>>
  <D.4697>:
  D.4781 = counter->type;
  D.4783 = D.4781 & 128;
  if (D.4783 != 0) goto <D.4784>; else goto <D.4785>;
  <D.4784>:
  D.4786 = counter->addr;
  D.4787 = (int (*<T987>) (void)) D.4786;
  intval = D.4787 ();
  goto <D.4788>;
  <D.4785>:
  D.4786 = counter->addr;
  intval = MEM[(int *)D.4786];
  <D.4788>:
  D.4789 = counter->name;
  fprintf (outfile, "%-36s: %d\n", D.4789, intval);
  goto <D.4698>;
  <D.4699>:
  D.4781 = counter->type;
  D.4783 = D.4781 & 128;
  if (D.4783 != 0) goto <D.4790>; else goto <D.4791>;
  <D.4790>:
  D.4786 = counter->addr;
  D.4792 = (guint (*<Te05>) (void)) D.4786;
  uintval = D.4792 ();
  goto <D.4793>;
  <D.4791>:
  D.4786 = counter->addr;
  uintval = MEM[(guint *)D.4786];
  <D.4793>:
  D.4789 = counter->name;
  fprintf (outfile, "%-36s: %u\n", D.4789, uintval);
  goto <D.4698>;
  <D.4700>:
  D.4781 = counter->type;
  D.4783 = D.4781 & 128;
  if (D.4783 != 0) goto <D.4794>; else goto <D.4795>;
  <D.4794>:
  D.4786 = counter->addr;
  D.4796 = (gint64 (*<Te0a>) (void)) D.4786;
  int64val = D.4796 ();
  goto <D.4797>;
  <D.4795>:
  D.4786 = counter->addr;
  int64val = MEM[(gint64 *)D.4786];
  <D.4797>:
  D.4789 = counter->name;
  fprintf (outfile, "%-36s: %lld\n", D.4789, int64val);
  goto <D.4698>;
  <D.4701>:
  D.4781 = counter->type;
  D.4783 = D.4781 & 128;
  if (D.4783 != 0) goto <D.4798>; else goto <D.4799>;
  <D.4798>:
  D.4786 = counter->addr;
  D.4800 = (guint64 (*<Te0f>) (void)) D.4786;
  uint64val = D.4800 ();
  goto <D.4801>;
  <D.4799>:
  D.4786 = counter->addr;
  uint64val = MEM[(guint64 *)D.4786];
  <D.4801>:
  D.4789 = counter->name;
  fprintf (outfile, "%-36s: %llu\n", D.4789, uint64val);
  goto <D.4698>;
  <D.4702>:
  D.4781 = counter->type;
  D.4783 = D.4781 & 128;
  if (D.4783 != 0) goto <D.4802>; else goto <D.4803>;
  <D.4802>:
  D.4786 = counter->addr;
  D.4804 = (gssize (*<Te14>) (void)) D.4786;
  wordval = D.4804 ();
  goto <D.4805>;
  <D.4803>:
  D.4786 = counter->addr;
  wordval = MEM[(gssize *)D.4786];
  <D.4805>:
  D.4789 = counter->name;
  fprintf (outfile, "%-36s: %d\n", D.4789, wordval);
  goto <D.4698>;
  <D.4703>:
  D.4781 = counter->type;
  D.4783 = D.4781 & 128;
  if (D.4783 != 0) goto <D.4806>; else goto <D.4807>;
  <D.4806>:
  D.4786 = counter->addr;
  D.4808 = (double (*<Te17>) (void)) D.4786;
  dval = D.4808 ();
  goto <D.4809>;
  <D.4807>:
  D.4786 = counter->addr;
  dval = MEM[(double *)D.4786];
  <D.4809>:
  D.4789 = counter->name;
  fprintf (outfile, "%-36s: %.4f\n", D.4789, dval);
  goto <D.4698>;
  <D.4704>:
  D.4781 = counter->type;
  D.4783 = D.4781 & 128;
  if (D.4783 != 0) goto <D.4810>; else goto <D.4811>;
  <D.4810>:
  D.4786 = counter->addr;
  D.4812 = (char * (*<Te1a>) (void)) D.4786;
  str = D.4812 ();
  goto <D.4813>;
  <D.4811>:
  D.4786 = counter->addr;
  str = MEM[(char * *)D.4786];
  <D.4813>:
  D.4789 = counter->name;
  fprintf (outfile, "%-36s: %s\n", D.4789, str);
  goto <D.4698>;
  <D.4705>:
  D.4781 = counter->type;
  D.4783 = D.4781 & 128;
  if (D.4783 != 0) goto <D.4814>; else goto <D.4815>;
  <D.4814>:
  D.4786 = counter->addr;
  D.4796 = (gint64 (*<Te0a>) (void)) D.4786;
  int64val = D.4796 ();
  goto <D.4816>;
  <D.4815>:
  D.4786 = counter->addr;
  int64val = MEM[(gint64 *)D.4786];
  <D.4816>:
  D.4789 = counter->name;
  D.4817 = (double) int64val;
  D.4818 = D.4817 / 1.0e+3;
  fprintf (outfile, "%-36s: %.2f ms\n", D.4789, D.4818);
  goto <D.4698>;
  <D.4819>:
  <D.4698>:
}


mono_counters_cleanup ()
{
  struct MonoCounter * counter;

  counter = counters;
  goto <D.4730>;
  <D.4729>:
  {
    struct MonoCounter * tmp;

    tmp = counters;
    counter = counter->next;
    free (tmp);
  }
  <D.4730>:
  if (counter != 0B) goto <D.4729>; else goto <D.4731>;
  <D.4731>:
  counters = 0B;
}


mono_runtime_resource_check_limit (int resource_type, uintptr_t value)
{
  void (*<Tdf2>) (int, uintptr_t, int) limit_reached.8;
  int D.4823;
  int D.4824;
  unsigned int D.4825;
  unsigned int D.4828;

  limit_reached.8 = limit_reached;
  if (limit_reached.8 == 0B) goto <D.4821>; else goto <D.4822>;
  <D.4821>:
  return;
  <D.4822>:
  D.4823 = resource_type * 2;
  D.4824 = D.4823 + 1;
  D.4825 = resource_limits[D.4824];
  if (D.4825 < value) goto <D.4826>; else goto <D.4827>;
  <D.4826>:
  limit_reached.8 = limit_reached;
  limit_reached.8 (resource_type, value, 0);
  return;
  <D.4827>:
  D.4823 = resource_type * 2;
  D.4828 = resource_limits[D.4823];
  if (D.4828 < value) goto <D.4829>; else goto <D.4830>;
  <D.4829>:
  limit_reached.8 = limit_reached;
  limit_reached.8 (resource_type, value, 1);
  <D.4830>:
}


mono_runtime_resource_limit (int resource_type, uintptr_t soft_limit, uintptr_t hard_limit)
{
  unsigned int resource_type.9;
  int D.4835;
  int D.4838;
  int D.4839;

  resource_type.9 = (unsigned int) resource_type;
  if (resource_type.9 > 2) goto <D.4833>; else goto <D.4834>;
  <D.4833>:
  D.4835 = 0;
  return D.4835;
  <D.4834>:
  if (soft_limit > hard_limit) goto <D.4836>; else goto <D.4837>;
  <D.4836>:
  D.4835 = 0;
  return D.4835;
  <D.4837>:
  D.4838 = resource_type * 2;
  resource_limits[D.4838] = soft_limit;
  D.4838 = resource_type * 2;
  D.4839 = D.4838 + 1;
  resource_limits[D.4839] = hard_limit;
  D.4835 = 1;
  return D.4835;
}


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