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

  valid_mask.1 = valid_mask;
  D.4729 = type & valid_mask.1;
  if (D.4729 == 0) goto <D.4730>; else goto <D.4731>;
  <D.4730>:
  return;
  <D.4731>:
  counter = malloc (16);
  if (counter == 0B) goto <D.4732>; else goto <D.4733>;
  <D.4732>:
  return;
  <D.4733>:
  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.4737>; else goto <D.4738>;
  <D.4737>:
  {
    struct MonoCounter * item;

    item = counters;
    goto <D.4650>;
    <D.4649>:
    item = item->next;
    <D.4650>:
    D.4739 = item->next;
    if (D.4739 != 0B) goto <D.4649>; else goto <D.4651>;
    <D.4651>:
    item->next = counter;
  }
  goto <D.4740>;
  <D.4738>:
  counters = counter;
  <D.4740>:
}


mono_counters_dump (int section_mask, struct FILE * outfile)
{
  int valid_mask.5;
  struct MonoCounter * counters.6;
  int D.4746;
  int set_mask.7;
  int D.4750;
  const char[10] * D.4753;
  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.4744>; else goto <D.4745>;
  <D.4744>:
  return;
  <D.4745>:
  j = 0;
  i = 256;
  goto <D.4702>;
  <D.4701>:
  D.4746 = section_mask & i;
  if (D.4746 != 0) goto <D.4747>; else goto <D.4748>;
  <D.4747>:
  set_mask.7 = set_mask;
  D.4750 = set_mask.7 & i;
  if (D.4750 != 0) goto <D.4751>; else goto <D.4752>;
  <D.4751>:
  D.4753 = &section_names[j];
  fprintf (outfile, "\n%s statistics\n", D.4753);
  mono_counters_dump_section (i, outfile);
  <D.4752>:
  <D.4748>:
  j = j + 1;
  i = i << 1;
  <D.4702>:
  if (i <= 4096) goto <D.4701>; else goto <D.4703>;
  <D.4703>:
  fflush (outfile);
}


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

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


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

  counter = counters;
  goto <D.4693>;
  <D.4692>:
  D.4757 = counter->type;
  D.4758 = D.4757 & section;
  if (D.4758 != 0) goto <D.4759>; else goto <D.4760>;
  <D.4759>:
  dump_counter (counter, outfile);
  <D.4760>:
  counter = counter->next;
  <D.4693>:
  if (counter != 0B) goto <D.4692>; else goto <D.4694>;
  <D.4694>:
}


dump_counter (struct MonoCounter * counter, struct FILE * outfile)
{
  int D.4761;
  int D.4762;
  int D.4763;
  void * D.4766;
  int (*<T97e>) (void) D.4767;
  const char * D.4769;
  guint (*<Tdfc>) (void) D.4772;
  gint64 (*<Te01>) (void) D.4776;
  guint64 (*<Te06>) (void) D.4780;
  gssize (*<Te0b>) (void) D.4784;
  double (*<Te0e>) (void) D.4788;
  char * (*<Te11>) (void) D.4792;
  double D.4797;
  double D.4798;
  int intval;
  guint uintval;
  gint64 int64val;
  guint64 uint64val;
  gssize wordval;
  double dval;
  const char * str;

  D.4761 = counter->type;
  D.4762 = D.4761 & 15;
  switch (D.4762) <default: <D.4799>, case 0: <D.4677>, case 1: <D.4679>, case 2: <D.4682>, case 3: <D.4680>, case 4: <D.4681>, case 5: <D.4683>, case 6: <D.4684>, case 7: <D.4685>>
  <D.4677>:
  D.4761 = counter->type;
  D.4763 = D.4761 & 128;
  if (D.4763 != 0) goto <D.4764>; else goto <D.4765>;
  <D.4764>:
  D.4766 = counter->addr;
  D.4767 = (int (*<T97e>) (void)) D.4766;
  intval = D.4767 ();
  goto <D.4768>;
  <D.4765>:
  D.4766 = counter->addr;
  intval = MEM[(int *)D.4766];
  <D.4768>:
  D.4769 = counter->name;
  fprintf (outfile, "%-36s: %d\n", D.4769, intval);
  goto <D.4678>;
  <D.4679>:
  D.4761 = counter->type;
  D.4763 = D.4761 & 128;
  if (D.4763 != 0) goto <D.4770>; else goto <D.4771>;
  <D.4770>:
  D.4766 = counter->addr;
  D.4772 = (guint (*<Tdfc>) (void)) D.4766;
  uintval = D.4772 ();
  goto <D.4773>;
  <D.4771>:
  D.4766 = counter->addr;
  uintval = MEM[(guint *)D.4766];
  <D.4773>:
  D.4769 = counter->name;
  fprintf (outfile, "%-36s: %u\n", D.4769, uintval);
  goto <D.4678>;
  <D.4680>:
  D.4761 = counter->type;
  D.4763 = D.4761 & 128;
  if (D.4763 != 0) goto <D.4774>; else goto <D.4775>;
  <D.4774>:
  D.4766 = counter->addr;
  D.4776 = (gint64 (*<Te01>) (void)) D.4766;
  int64val = D.4776 ();
  goto <D.4777>;
  <D.4775>:
  D.4766 = counter->addr;
  int64val = MEM[(gint64 *)D.4766];
  <D.4777>:
  D.4769 = counter->name;
  fprintf (outfile, "%-36s: %lld\n", D.4769, int64val);
  goto <D.4678>;
  <D.4681>:
  D.4761 = counter->type;
  D.4763 = D.4761 & 128;
  if (D.4763 != 0) goto <D.4778>; else goto <D.4779>;
  <D.4778>:
  D.4766 = counter->addr;
  D.4780 = (guint64 (*<Te06>) (void)) D.4766;
  uint64val = D.4780 ();
  goto <D.4781>;
  <D.4779>:
  D.4766 = counter->addr;
  uint64val = MEM[(guint64 *)D.4766];
  <D.4781>:
  D.4769 = counter->name;
  fprintf (outfile, "%-36s: %llu\n", D.4769, uint64val);
  goto <D.4678>;
  <D.4682>:
  D.4761 = counter->type;
  D.4763 = D.4761 & 128;
  if (D.4763 != 0) goto <D.4782>; else goto <D.4783>;
  <D.4782>:
  D.4766 = counter->addr;
  D.4784 = (gssize (*<Te0b>) (void)) D.4766;
  wordval = D.4784 ();
  goto <D.4785>;
  <D.4783>:
  D.4766 = counter->addr;
  wordval = MEM[(gssize *)D.4766];
  <D.4785>:
  D.4769 = counter->name;
  fprintf (outfile, "%-36s: %d\n", D.4769, wordval);
  goto <D.4678>;
  <D.4683>:
  D.4761 = counter->type;
  D.4763 = D.4761 & 128;
  if (D.4763 != 0) goto <D.4786>; else goto <D.4787>;
  <D.4786>:
  D.4766 = counter->addr;
  D.4788 = (double (*<Te0e>) (void)) D.4766;
  dval = D.4788 ();
  goto <D.4789>;
  <D.4787>:
  D.4766 = counter->addr;
  dval = MEM[(double *)D.4766];
  <D.4789>:
  D.4769 = counter->name;
  fprintf (outfile, "%-36s: %.4f\n", D.4769, dval);
  goto <D.4678>;
  <D.4684>:
  D.4761 = counter->type;
  D.4763 = D.4761 & 128;
  if (D.4763 != 0) goto <D.4790>; else goto <D.4791>;
  <D.4790>:
  D.4766 = counter->addr;
  D.4792 = (char * (*<Te11>) (void)) D.4766;
  str = D.4792 ();
  goto <D.4793>;
  <D.4791>:
  D.4766 = counter->addr;
  str = MEM[(char * *)D.4766];
  <D.4793>:
  D.4769 = counter->name;
  fprintf (outfile, "%-36s: %s\n", D.4769, str);
  goto <D.4678>;
  <D.4685>:
  D.4761 = counter->type;
  D.4763 = D.4761 & 128;
  if (D.4763 != 0) goto <D.4794>; else goto <D.4795>;
  <D.4794>:
  D.4766 = counter->addr;
  D.4776 = (gint64 (*<Te01>) (void)) D.4766;
  int64val = D.4776 ();
  goto <D.4796>;
  <D.4795>:
  D.4766 = counter->addr;
  int64val = MEM[(gint64 *)D.4766];
  <D.4796>:
  D.4797 = (double) int64val;
  D.4798 = D.4797 / 1.0e+3;
  D.4769 = counter->name;
  fprintf (outfile, "%-36s: %.2f ms\n", D.4769, D.4798);
  goto <D.4678>;
  <D.4799>:
  <D.4678>:
}


mono_counters_cleanup ()
{
  struct MonoCounter * counter;

  counter = counters;
  goto <D.4710>;
  <D.4709>:
  {
    struct MonoCounter * tmp;

    tmp = counters;
    counter = counter->next;
    free (tmp);
  }
  <D.4710>:
  if (counter != 0B) goto <D.4709>; else goto <D.4711>;
  <D.4711>:
  counters = 0B;
}


mono_runtime_resource_check_limit (int resource_type, uintptr_t value)
{
  void (*<Tde9>) (int, uintptr_t, int) limit_reached.8;
  int D.4803;
  int D.4804;
  unsigned int D.4805;
  unsigned int D.4808;

  limit_reached.8 = limit_reached;
  if (limit_reached.8 == 0B) goto <D.4801>; else goto <D.4802>;
  <D.4801>:
  return;
  <D.4802>:
  D.4803 = resource_type * 2;
  D.4804 = D.4803 + 1;
  D.4805 = resource_limits[D.4804];
  if (D.4805 < value) goto <D.4806>; else goto <D.4807>;
  <D.4806>:
  limit_reached.8 = limit_reached;
  limit_reached.8 (resource_type, value, 0);
  return;
  <D.4807>:
  D.4803 = resource_type * 2;
  D.4808 = resource_limits[D.4803];
  if (D.4808 < value) goto <D.4809>; else goto <D.4810>;
  <D.4809>:
  limit_reached.8 = limit_reached;
  limit_reached.8 (resource_type, value, 1);
  <D.4810>:
}


mono_runtime_resource_limit (int resource_type, uintptr_t soft_limit, uintptr_t hard_limit)
{
  unsigned int resource_type.9;
  int D.4815;
  int D.4818;
  int D.4819;

  resource_type.9 = (unsigned int) resource_type;
  if (resource_type.9 > 2) goto <D.4813>; else goto <D.4814>;
  <D.4813>:
  D.4815 = 0;
  return D.4815;
  <D.4814>:
  if (soft_limit > hard_limit) goto <D.4816>; else goto <D.4817>;
  <D.4816>:
  D.4815 = 0;
  return D.4815;
  <D.4817>:
  D.4818 = resource_type * 2;
  resource_limits[D.4818] = soft_limit;
  D.4818 = resource_type * 2;
  D.4819 = D.4818 + 1;
  resource_limits[D.4819] = hard_limit;
  D.4815 = 1;
  return D.4815;
}


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