__attribute__((visibility ("hidden")))
mono_trace_cleanup ()
{
  struct GQueue * level_stack.0;
  void * D.5216;
  int D.5217;

  level_stack.0 = level_stack;
  if (level_stack.0 != 0B) goto <D.5214>; else goto <D.5215>;
  <D.5214>:
  goto <D.5151>;
  <D.5150>:
  level_stack.0 = level_stack;
  D.5216 = monoeg_g_queue_pop_head (level_stack.0);
  monoeg_g_free (D.5216);
  <D.5151>:
  level_stack.0 = level_stack;
  D.5217 = monoeg_g_queue_is_empty (level_stack.0);
  if (D.5217 == 0) goto <D.5150>; else goto <D.5152>;
  <D.5152>:
  level_stack.0 = level_stack;
  monoeg_g_queue_free (level_stack.0);
  level_stack = 0B;
  <D.5215>:
}


__attribute__((visibility ("hidden")))
mono_trace (GLogLevelFlags level, MonoTraceMask mask, const char * format)
{
  struct GQueue * level_stack.1;
  <unnamed type> current_level.2;
  <unnamed type> current_mask.3;
  unsigned int D.5225;
  const char * mono_log_domain.4;

  level_stack.1 = level_stack;
  if (level_stack.1 == 0B) goto <D.5219>; else goto <D.5220>;
  <D.5219>:
  mono_trace_init ();
  <D.5220>:
  current_level.2 = current_level;
  if (level <= current_level.2) goto <D.5222>; else goto <D.5223>;
  <D.5222>:
  current_mask.3 = current_mask;
  D.5225 = mask & current_mask.3;
  if (D.5225 != 0) goto <D.5226>; else goto <D.5227>;
  <D.5226>:
  {
    struct  args[1];

    try
      {
        __builtin_va_start (&args, 0);
        mono_log_domain.4 = mono_log_domain;
        monoeg_g_logv (mono_log_domain.4, level, format, &args);
        __builtin_va_end (&args);
      }
    finally
      {
        args = {CLOBBER};
      }
  }
  <D.5227>:
  <D.5223>:
}


mono_trace_init ()
{
  struct GQueue * level_stack.5;
  struct GQueue * D.5232;
  const gchar * D.5233;
  const gchar * D.5234;

  level_stack.5 = level_stack;
  if (level_stack.5 == 0B) goto <D.5230>; else goto <D.5231>;
  <D.5230>:
  D.5232 = monoeg_g_queue_new ();
  level_stack = D.5232;
  D.5233 = monoeg_g_getenv ("MONO_LOG_MASK");
  mono_trace_set_mask_string (D.5233);
  D.5234 = monoeg_g_getenv ("MONO_LOG_LEVEL");
  mono_trace_set_level_string (D.5234);
  <D.5231>:
}


__attribute__((visibility ("hidden")))
mono_tracev (GLogLevelFlags level, MonoTraceMask mask, const char * format, struct  * args)
{
  struct GQueue * level_stack.6;
  <unnamed type> current_level.7;
  <unnamed type> current_mask.8;
  unsigned int D.5242;
  const char * mono_log_domain.9;

  level_stack.6 = level_stack;
  if (level_stack.6 == 0B) goto <D.5236>; else goto <D.5237>;
  <D.5236>:
  mono_trace_init ();
  <D.5237>:
  current_level.7 = current_level;
  if (level <= current_level.7) goto <D.5239>; else goto <D.5240>;
  <D.5239>:
  current_mask.8 = current_mask;
  D.5242 = mask & current_mask.8;
  if (D.5242 != 0) goto <D.5243>; else goto <D.5244>;
  <D.5243>:
  mono_log_domain.9 = mono_log_domain;
  monoeg_g_logv (mono_log_domain.9, level, format, args);
  <D.5244>:
  <D.5240>:
}


__attribute__((visibility ("hidden")))
mono_trace_set_level (GLogLevelFlags level)
{
  struct GQueue * level_stack.10;

  level_stack.10 = level_stack;
  if (level_stack.10 == 0B) goto <D.5247>; else goto <D.5248>;
  <D.5247>:
  mono_trace_init ();
  <D.5248>:
  current_level = level;
}


__attribute__((visibility ("hidden")))
mono_trace_set_mask (MonoTraceMask mask)
{
  struct GQueue * level_stack.11;

  level_stack.11 = level_stack;
  if (level_stack.11 == 0B) goto <D.5250>; else goto <D.5251>;
  <D.5250>:
  mono_trace_init ();
  <D.5251>:
  current_mask = mask;
}


__attribute__((visibility ("hidden")))
mono_trace_push (GLogLevelFlags level, MonoTraceMask mask)
{
  struct GQueue * level_stack.12;
  <unnamed type> current_level.13;
  <unnamed type> current_mask.14;
  static const char __func__[16] = "mono_trace_push";

  level_stack.12 = level_stack;
  if (level_stack.12 == 0B) goto <D.5253>; else goto <D.5254>;
  <D.5253>:
  monoeg_g_log (0B, 4, "%s: cannot use mono_trace_push without calling mono_trace_init first.", &__func__);
  <D.5176>:
  goto <D.5176>;
  <D.5254>:
  {
    struct MonoLogLevelEntry * entry;

    entry = monoeg_malloc (8);
    current_level.13 = current_level;
    entry->level = current_level.13;
    current_mask.14 = current_mask;
    entry->mask = current_mask.14;
    level_stack.12 = level_stack;
    monoeg_g_queue_push_head (level_stack.12, entry);
    current_level = level;
    current_mask = mask;
  }
}


__attribute__((visibility ("hidden")))
mono_trace_pop ()
{
  struct GQueue * level_stack.15;
  int D.5260;
  <unnamed type> D.5263;
  <unnamed type> D.5264;
  static const char __func__[15] = "mono_trace_pop";

  level_stack.15 = level_stack;
  if (level_stack.15 == 0B) goto <D.5258>; else goto <D.5259>;
  <D.5258>:
  monoeg_g_log (0B, 4, "%s: cannot use mono_trace_pop without calling mono_trace_init first.", &__func__);
  <D.5182>:
  goto <D.5182>;
  <D.5259>:
  level_stack.15 = level_stack;
  D.5260 = monoeg_g_queue_is_empty (level_stack.15);
  if (D.5260 == 0) goto <D.5261>; else goto <D.5262>;
  <D.5261>:
  {
    struct MonoLogLevelEntry * entry;

    level_stack.15 = level_stack;
    entry = monoeg_g_queue_pop_head (level_stack.15);
    D.5263 = entry->level;
    current_level = D.5263;
    D.5264 = entry->mask;
    current_mask = D.5264;
    monoeg_g_free (entry);
  }
  <D.5262>:
}


mono_trace_set_level_string (const char * value)
{
  const char * D.5275;
  int D.5276;
  <unnamed type> D.5279;
  char D.5280;
  int i;
  const char * valid_vals[7];
  const GLogLevelFlags valid_ids[6];

  try
    {
      i = 0;
      valid_vals = *.LC6;
      valid_ids = *.LC7;
      if (value == 0B) goto <D.5273>; else goto <D.5274>;
      <D.5273>:
      return;
      <D.5274>:
      goto <D.5191>;
      <D.5190>:
      D.5275 = valid_vals[i];
      D.5276 = strcmp (D.5275, value);
      if (D.5276 == 0) goto <D.5277>; else goto <D.5278>;
      <D.5277>:
      D.5279 = valid_ids[i];
      mono_trace_set_level (D.5279);
      return;
      <D.5278>:
      i = i + 1;
      <D.5191>:
      D.5275 = valid_vals[i];
      if (D.5275 != 0B) goto <D.5190>; else goto <D.5192>;
      <D.5192>:
      D.5280 = *value;
      if (D.5280 != 0) goto <D.5281>; else goto <D.5282>;
      <D.5281>:
      monoeg_g_print ("Unknown trace loglevel: %s\n", value);
      <D.5282>:
    }
  finally
    {
      valid_vals = {CLOBBER};
      valid_ids = {CLOBBER};
    }
}


__attribute__((__gnu_inline__, nothrow, leaf, pure))
strcmp (const char * __s1, const char * __s2)
{
  int iftmp.16;
  int iftmp.17;
  int D.5294;
  char * __p1;
  char * __p2;
  int __ret;

  __p1 = __s1;
  __p2 = __s2;
  __asm__ __volatile__("   slr   0,0
0: clst  %1,%2
   jo    0b
   ipm   %0
   srl   %0,28" : "=d" __ret, "=&a" __p1, "=&a" __p2 : "1" __p1, "2" __p2 : "0", "memory", "cc");
  if (__ret != 0) goto <D.5287>; else goto <D.5288>;
  <D.5287>:
  if (__ret == 1) goto <D.5290>; else goto <D.5291>;
  <D.5290>:
  iftmp.17 = -1;
  goto <D.5292>;
  <D.5291>:
  iftmp.17 = 1;
  <D.5292>:
  iftmp.16 = iftmp.17;
  goto <D.5293>;
  <D.5288>:
  iftmp.16 = 0;
  <D.5293>:
  __ret = iftmp.16;
  D.5294 = __ret;
  return D.5294;
}


mono_trace_set_mask_string (const char * value)
{
  char D.5308;
  const char * D.5311;
  long unsigned int D.5312;
  long unsigned int D.5315;
  int D.5316;
  sizetype D.5319;
  const char * D.5320;
  char D.5321;
  <unnamed type> D.5323;
  int i;
  const char * tok;
  guint32 flags;
  const char * valid_flags[9];
  const MonoTraceMask valid_masks[8];

  try
    {
      flags = 0;
      valid_flags = *.LC16;
      valid_masks = *.LC17;
      if (value == 0B) goto <D.5306>; else goto <D.5307>;
      <D.5306>:
      return;
      <D.5307>:
      tok = value;
      goto <D.5201>;
      <D.5207>:
      D.5308 = *tok;
      if (D.5308 == 44) goto <D.5309>; else goto <D.5310>;
      <D.5309>:
      tok = tok + 1;
      // predicted unlikely by continue predictor.
      goto <D.5201>;
      <D.5310>:
      i = 0;
      goto <D.5205>;
      <D.5204>:
      {
        int len;

        D.5311 = valid_flags[i];
        D.5312 = __strlen_g (D.5311);
        len = (int) D.5312;
        D.5311 = valid_flags[i];
        D.5315 = (long unsigned int) len;
        D.5316 = strncmp (tok, D.5311, D.5315);
        if (D.5316 == 0) goto <D.5317>; else goto <D.5318>;
        <D.5317>:
        D.5319 = (sizetype) len;
        D.5320 = tok + D.5319;
        D.5321 = *D.5320;
        if (D.5321 == 0) goto <D.5313>; else goto <D.5322>;
        <D.5322>:
        D.5319 = (sizetype) len;
        D.5320 = tok + D.5319;
        D.5321 = *D.5320;
        if (D.5321 == 44) goto <D.5313>; else goto <D.5314>;
        <D.5313>:
        D.5323 = valid_masks[i];
        flags = D.5323 | flags;
        D.5319 = (sizetype) len;
        tok = tok + D.5319;
        goto <D.5203>;
        <D.5314>:
        <D.5318>:
      }
      i = i + 1;
      <D.5205>:
      D.5311 = valid_flags[i];
      if (D.5311 != 0B) goto <D.5204>; else goto <D.5203>;
      <D.5203>:
      D.5311 = valid_flags[i];
      if (D.5311 == 0B) goto <D.5324>; else goto <D.5325>;
      <D.5324>:
      monoeg_g_print ("Unknown trace flag: %s\n", tok);
      goto <D.5206>;
      <D.5325>:
      <D.5201>:
      D.5308 = *tok;
      if (D.5308 != 0) goto <D.5207>; else goto <D.5206>;
      <D.5206>:
      mono_trace_set_mask (flags);
    }
  finally
    {
      valid_flags = {CLOBBER};
      valid_masks = {CLOBBER};
    }
}


__attribute__((__gnu_inline__))
__strlen_g (const char * __str)
{
  size_t D.5329;
  long int __ptr.18;
  long int __str.19;
  long int D.5332;
  char * __ptr;
  char * __tmp;

  __ptr = 0B;
  __tmp = __str;
  __asm__ __volatile__("   la    0,0
0: srst  %0,%1
   jo    0b
" : "=&a" __ptr, "=&a" __tmp : "0" __ptr, "1" __tmp : "0", "memory", "cc");
  __ptr.18 = (long int) __ptr;
  __str.19 = (long int) __str;
  D.5332 = __ptr.18 - __str.19;
  D.5329 = (size_t) D.5332;
  return D.5329;
}


__attribute__((visibility ("hidden")))
mono_trace_is_traced (GLogLevelFlags level, MonoTraceMask mask)
{
  gboolean D.5334;
  int iftmp.20;
  <unnamed type> current_level.21;
  <unnamed type> current_mask.22;
  unsigned int D.5341;

  current_level.21 = current_level;
  if (level <= current_level.21) goto <D.5339>; else goto <D.5336>;
  <D.5339>:
  current_mask.22 = current_mask;
  D.5341 = mask & current_mask.22;
  if (D.5341 != 0) goto <D.5342>; else goto <D.5336>;
  <D.5342>:
  iftmp.20 = 1;
  goto <D.5337>;
  <D.5336>:
  iftmp.20 = 0;
  <D.5337>:
  D.5334 = iftmp.20;
  return D.5334;
}