mono_counters_enable (int section_mask)
{
  int D.5244;

  D.5244 = section_mask & -256;
  valid_mask = D.5244;
}


mono_counters_register (const char * name, int type, void * addr)
{
  int valid_mask.0;
  int D.5246;
  int set_mask.1;
  int D.5252;
  struct MonoCounter * counters.2;
  struct MonoCounter * D.5256;
  struct MonoCounter * counter;

  valid_mask.0 = valid_mask;
  D.5246 = type & valid_mask.0;
  if (D.5246 == 0) goto <D.5247>; else goto <D.5248>;
  <D.5247>:
  return;
  <D.5248>:
  counter = malloc (32);
  if (counter == 0B) goto <D.5249>; else goto <D.5250>;
  <D.5249>:
  return;
  <D.5250>:
  counter->name = name;
  counter->type = type;
  counter->addr = addr;
  counter->next = 0B;
  set_mask.1 = set_mask;
  D.5252 = set_mask.1 | type;
  set_mask = D.5252;
  counters.2 = counters;
  if (counters.2 != 0B) goto <D.5254>; else goto <D.5255>;
  <D.5254>:
  {
    struct MonoCounter * item;

    item = counters;
    goto <D.5167>;
    <D.5166>:
    item = item->next;
    <D.5167>:
    D.5256 = item->next;
    if (D.5256 != 0B) goto <D.5166>; else goto <D.5168>;
    <D.5168>:
    item->next = counter;
  }
  goto <D.5257>;
  <D.5255>:
  counters = counter;
  <D.5257>:
}


mono_counters_dump (int section_mask, struct FILE * outfile)
{
  int valid_mask.3;
  struct MonoCounter * counters.4;
  int D.5263;
  int set_mask.5;
  int D.5267;
  const char[10] * D.5270;
  int i;
  int j;

  valid_mask.3 = valid_mask;
  section_mask = section_mask & valid_mask.3;
  counters.4 = counters;
  if (counters.4 == 0B) goto <D.5261>; else goto <D.5262>;
  <D.5261>:
  return;
  <D.5262>:
  j = 0;
  i = 256;
  goto <D.5219>;
  <D.5218>:
  D.5263 = section_mask & i;
  if (D.5263 != 0) goto <D.5264>; else goto <D.5265>;
  <D.5264>:
  set_mask.5 = set_mask;
  D.5267 = set_mask.5 & i;
  if (D.5267 != 0) goto <D.5268>; else goto <D.5269>;
  <D.5268>:
  D.5270 = &section_names[j];
  fprintf (outfile, "\n%s statistics\n", D.5270);
  mono_counters_dump_section (i, outfile);
  <D.5269>:
  <D.5265>:
  j = j + 1;
  i = i << 1;
  <D.5219>:
  if (i <= 4096) goto <D.5218>; else goto <D.5220>;
  <D.5220>:
  fflush (outfile);
}


__attribute__((__artificial__, __gnu_inline__, __always_inline__))
fprintf (struct FILE * restrict __stream, const char * restrict __fmt)
{
  int D.5272;

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


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

  counter = counters;
  goto <D.5210>;
  <D.5209>:
  D.5274 = counter->type;
  D.5275 = D.5274 & section;
  if (D.5275 != 0) goto <D.5276>; else goto <D.5277>;
  <D.5276>:
  dump_counter (counter, outfile);
  <D.5277>:
  counter = counter->next;
  <D.5210>:
  if (counter != 0B) goto <D.5209>; else goto <D.5211>;
  <D.5211>:
}


dump_counter (struct MonoCounter * counter, struct FILE * outfile)
{
  int D.5278;
  int D.5279;
  int D.5280;
  void * D.5283;
  int (*<Tb48>) (void) D.5284;
  const char * D.5286;
  guint (*<Tfb3>) (void) D.5289;
  gint64 (*<Tfb8>) (void) D.5293;
  guint64 (*<Tfbd>) (void) D.5297;
  gssize (*<Tfc2>) (void) D.5301;
  int D.5303;
  double (*<Tfc5>) (void) D.5306;
  char * (*<Tfc8>) (void) D.5310;
  double D.5315;
  double D.5316;
  int intval;
  guint uintval;
  gint64 int64val;
  guint64 uint64val;
  gssize wordval;
  double dval;
  const char * str;

  D.5278 = counter->type;
  D.5279 = D.5278 & 15;
  switch (D.5279) <default: <D.5317>, case 0: <D.5194>, case 1: <D.5196>, case 2: <D.5199>, case 3: <D.5197>, case 4: <D.5198>, case 5: <D.5200>, case 6: <D.5201>, case 7: <D.5202>>
  <D.5194>:
  D.5278 = counter->type;
  D.5280 = D.5278 & 128;
  if (D.5280 != 0) goto <D.5281>; else goto <D.5282>;
  <D.5281>:
  D.5283 = counter->addr;
  D.5284 = (int (*<Tb48>) (void)) D.5283;
  intval = D.5284 ();
  goto <D.5285>;
  <D.5282>:
  D.5283 = counter->addr;
  intval = MEM[(int *)D.5283];
  <D.5285>:
  D.5286 = counter->name;
  fprintf (outfile, "%-36s: %d\n", D.5286, intval);
  goto <D.5195>;
  <D.5196>:
  D.5278 = counter->type;
  D.5280 = D.5278 & 128;
  if (D.5280 != 0) goto <D.5287>; else goto <D.5288>;
  <D.5287>:
  D.5283 = counter->addr;
  D.5289 = (guint (*<Tfb3>) (void)) D.5283;
  uintval = D.5289 ();
  goto <D.5290>;
  <D.5288>:
  D.5283 = counter->addr;
  uintval = MEM[(guint *)D.5283];
  <D.5290>:
  D.5286 = counter->name;
  fprintf (outfile, "%-36s: %u\n", D.5286, uintval);
  goto <D.5195>;
  <D.5197>:
  D.5278 = counter->type;
  D.5280 = D.5278 & 128;
  if (D.5280 != 0) goto <D.5291>; else goto <D.5292>;
  <D.5291>:
  D.5283 = counter->addr;
  D.5293 = (gint64 (*<Tfb8>) (void)) D.5283;
  int64val = D.5293 ();
  goto <D.5294>;
  <D.5292>:
  D.5283 = counter->addr;
  int64val = MEM[(gint64 *)D.5283];
  <D.5294>:
  D.5286 = counter->name;
  fprintf (outfile, "%-36s: %lld\n", D.5286, int64val);
  goto <D.5195>;
  <D.5198>:
  D.5278 = counter->type;
  D.5280 = D.5278 & 128;
  if (D.5280 != 0) goto <D.5295>; else goto <D.5296>;
  <D.5295>:
  D.5283 = counter->addr;
  D.5297 = (guint64 (*<Tfbd>) (void)) D.5283;
  uint64val = D.5297 ();
  goto <D.5298>;
  <D.5296>:
  D.5283 = counter->addr;
  uint64val = MEM[(guint64 *)D.5283];
  <D.5298>:
  D.5286 = counter->name;
  fprintf (outfile, "%-36s: %llu\n", D.5286, uint64val);
  goto <D.5195>;
  <D.5199>:
  D.5278 = counter->type;
  D.5280 = D.5278 & 128;
  if (D.5280 != 0) goto <D.5299>; else goto <D.5300>;
  <D.5299>:
  D.5283 = counter->addr;
  D.5301 = (gssize (*<Tfc2>) (void)) D.5283;
  wordval = D.5301 ();
  goto <D.5302>;
  <D.5300>:
  D.5283 = counter->addr;
  wordval = MEM[(gssize *)D.5283];
  <D.5302>:
  D.5286 = counter->name;
  D.5303 = (int) wordval;
  fprintf (outfile, "%-36s: %d\n", D.5286, D.5303);
  goto <D.5195>;
  <D.5200>:
  D.5278 = counter->type;
  D.5280 = D.5278 & 128;
  if (D.5280 != 0) goto <D.5304>; else goto <D.5305>;
  <D.5304>:
  D.5283 = counter->addr;
  D.5306 = (double (*<Tfc5>) (void)) D.5283;
  dval = D.5306 ();
  goto <D.5307>;
  <D.5305>:
  D.5283 = counter->addr;
  dval = MEM[(double *)D.5283];
  <D.5307>:
  D.5286 = counter->name;
  fprintf (outfile, "%-36s: %.4f\n", D.5286, dval);
  goto <D.5195>;
  <D.5201>:
  D.5278 = counter->type;
  D.5280 = D.5278 & 128;
  if (D.5280 != 0) goto <D.5308>; else goto <D.5309>;
  <D.5308>:
  D.5283 = counter->addr;
  D.5310 = (char * (*<Tfc8>) (void)) D.5283;
  str = D.5310 ();
  goto <D.5311>;
  <D.5309>:
  D.5283 = counter->addr;
  str = MEM[(char * *)D.5283];
  <D.5311>:
  D.5286 = counter->name;
  fprintf (outfile, "%-36s: %s\n", D.5286, str);
  goto <D.5195>;
  <D.5202>:
  D.5278 = counter->type;
  D.5280 = D.5278 & 128;
  if (D.5280 != 0) goto <D.5312>; else goto <D.5313>;
  <D.5312>:
  D.5283 = counter->addr;
  D.5293 = (gint64 (*<Tfb8>) (void)) D.5283;
  int64val = D.5293 ();
  goto <D.5314>;
  <D.5313>:
  D.5283 = counter->addr;
  int64val = MEM[(gint64 *)D.5283];
  <D.5314>:
  D.5286 = counter->name;
  D.5315 = (double) int64val;
  D.5316 = D.5315 / 1.0e+3;
  fprintf (outfile, "%-36s: %.2f ms\n", D.5286, D.5316);
  goto <D.5195>;
  <D.5317>:
  <D.5195>:
}


mono_counters_cleanup ()
{
  struct MonoCounter * counter;

  counter = counters;
  goto <D.5227>;
  <D.5226>:
  {
    struct MonoCounter * tmp;

    tmp = counters;
    counter = counter->next;
    free (tmp);
  }
  <D.5227>:
  if (counter != 0B) goto <D.5226>; else goto <D.5228>;
  <D.5228>:
  counters = 0B;
}


mono_runtime_resource_check_limit (int resource_type, uintptr_t value)
{
  void (*<Tfa0>) (int, uintptr_t, int) limit_reached.6;
  int D.5321;
  int D.5322;
  long unsigned int D.5323;
  long unsigned int D.5326;

  limit_reached.6 = limit_reached;
  if (limit_reached.6 == 0B) goto <D.5319>; else goto <D.5320>;
  <D.5319>:
  return;
  <D.5320>:
  D.5321 = resource_type * 2;
  D.5322 = D.5321 + 1;
  D.5323 = resource_limits[D.5322];
  if (D.5323 < value) goto <D.5324>; else goto <D.5325>;
  <D.5324>:
  limit_reached.6 = limit_reached;
  limit_reached.6 (resource_type, value, 0);
  return;
  <D.5325>:
  D.5321 = resource_type * 2;
  D.5326 = resource_limits[D.5321];
  if (D.5326 < value) goto <D.5327>; else goto <D.5328>;
  <D.5327>:
  limit_reached.6 = limit_reached;
  limit_reached.6 (resource_type, value, 1);
  <D.5328>:
}


mono_runtime_resource_limit (int resource_type, uintptr_t soft_limit, uintptr_t hard_limit)
{
  unsigned int resource_type.7;
  int D.5333;
  int D.5336;
  int D.5337;

  resource_type.7 = (unsigned int) resource_type;
  if (resource_type.7 > 2) goto <D.5331>; else goto <D.5332>;
  <D.5331>:
  D.5333 = 0;
  return D.5333;
  <D.5332>:
  if (soft_limit > hard_limit) goto <D.5334>; else goto <D.5335>;
  <D.5334>:
  D.5333 = 0;
  return D.5333;
  <D.5335>:
  D.5336 = resource_type * 2;
  resource_limits[D.5336] = soft_limit;
  D.5336 = resource_type * 2;
  D.5337 = D.5336 + 1;
  resource_limits[D.5337] = hard_limit;
  D.5333 = 1;
  return D.5333;
}


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