mono_trace_cleanup ()
{
  struct GQueue * level_stack.0;
  void * D.5581;
  int D.5582;

  level_stack.0 = level_stack;
  if (level_stack.0 != 0B) goto <D.5579>; else goto <D.5580>;
  <D.5579>:
  goto <D.5498>;
  <D.5497>:
  level_stack.0 = level_stack;
  D.5581 = monoeg_g_queue_pop_head (level_stack.0);
  monoeg_g_free (D.5581);
  <D.5498>:
  level_stack.0 = level_stack;
  D.5582 = monoeg_g_queue_is_empty (level_stack.0);
  if (D.5582 == 0) goto <D.5497>; else goto <D.5499>;
  <D.5499>:
  level_stack.0 = level_stack;
  monoeg_g_queue_free (level_stack.0);
  level_stack = 0B;
  <D.5580>:
}


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.5590;
  const char * mono_log_domain.4;
  char * args.5;

  level_stack.1 = level_stack;
  if (level_stack.1 == 0B) goto <D.5584>; else goto <D.5585>;
  <D.5584>:
  mono_trace_init ();
  <D.5585>:
  current_level.2 = current_level;
  if (level <= current_level.2) goto <D.5587>; else goto <D.5588>;
  <D.5587>:
  current_mask.3 = current_mask;
  D.5590 = mask & current_mask.3;
  if (D.5590 != 0) goto <D.5591>; else goto <D.5592>;
  <D.5591>:
  {
    char * args;

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


mono_trace_init ()
{
  struct GQueue * level_stack.6;
  struct GQueue * level_stack.7;
  const gchar * D.5599;
  const gchar * D.5600;

  level_stack.6 = level_stack;
  if (level_stack.6 == 0B) goto <D.5596>; else goto <D.5597>;
  <D.5596>:
  level_stack.7 = monoeg_g_queue_new ();
  level_stack = level_stack.7;
  D.5599 = monoeg_g_getenv ("MONO_LOG_MASK");
  mono_trace_set_mask_string (D.5599);
  D.5600 = monoeg_g_getenv ("MONO_LOG_LEVEL");
  mono_trace_set_level_string (D.5600);
  <D.5597>:
}


mono_tracev (GLogLevelFlags level, MonoTraceMask mask, const char * format, char * args)
{
  struct GQueue * level_stack.8;
  <unnamed type> current_level.9;
  <unnamed type> current_mask.10;
  unsigned int D.5608;
  const char * mono_log_domain.11;

  level_stack.8 = level_stack;
  if (level_stack.8 == 0B) goto <D.5602>; else goto <D.5603>;
  <D.5602>:
  mono_trace_init ();
  <D.5603>:
  current_level.9 = current_level;
  if (level <= current_level.9) goto <D.5605>; else goto <D.5606>;
  <D.5605>:
  current_mask.10 = current_mask;
  D.5608 = mask & current_mask.10;
  if (D.5608 != 0) goto <D.5609>; else goto <D.5610>;
  <D.5609>:
  mono_log_domain.11 = mono_log_domain;
  monoeg_g_logv (mono_log_domain.11, level, format, args);
  <D.5610>:
  <D.5606>:
}


mono_trace_set_level (GLogLevelFlags level)
{
  struct GQueue * level_stack.12;

  level_stack.12 = level_stack;
  if (level_stack.12 == 0B) goto <D.5613>; else goto <D.5614>;
  <D.5613>:
  mono_trace_init ();
  <D.5614>:
  current_level = level;
}


mono_trace_set_mask (MonoTraceMask mask)
{
  struct GQueue * level_stack.13;

  level_stack.13 = level_stack;
  if (level_stack.13 == 0B) goto <D.5616>; else goto <D.5617>;
  <D.5616>:
  mono_trace_init ();
  <D.5617>:
  current_mask = mask;
}


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

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

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


mono_trace_pop ()
{
  struct GQueue * level_stack.17;
  int D.5626;
  <unnamed type> current_level.18;
  <unnamed type> current_mask.19;
  static const char __func__[15] = "mono_trace_pop";

  level_stack.17 = level_stack;
  if (level_stack.17 == 0B) goto <D.5624>; else goto <D.5625>;
  <D.5624>:
  monoeg_g_log (0B, 4, "%s: cannot use mono_trace_pop without calling mono_trace_init first.", &__func__);
  <D.5529>:
  goto <D.5529>;
  <D.5625>:
  level_stack.17 = level_stack;
  D.5626 = monoeg_g_queue_is_empty (level_stack.17);
  if (D.5626 == 0) goto <D.5627>; else goto <D.5628>;
  <D.5627>:
  {
    struct MonoLogLevelEntry * entry;

    level_stack.17 = level_stack;
    entry = monoeg_g_queue_pop_head (level_stack.17);
    current_level.18 = entry->level;
    current_level = current_level.18;
    current_mask.19 = entry->mask;
    current_mask = current_mask.19;
    monoeg_g_free (entry);
  }
  <D.5628>:
}


mono_trace_set_level_string (const char * value)
{
  int D.5545;
  const char * D.5641;
  <unnamed type> D.5644;
  char D.5645;
  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.5639>; else goto <D.5640>;
      <D.5639>:
      return;
      <D.5640>:
      goto <D.5547>;
      <D.5546>:
      {
        size_t __s1_len;
        size_t __s2_len;

        D.5641 = valid_vals[i];
        D.5545 = __builtin_strcmp (D.5641, value);
      }
      if (D.5545 == 0) goto <D.5642>; else goto <D.5643>;
      <D.5642>:
      D.5644 = valid_ids[i];
      mono_trace_set_level (D.5644);
      return;
      <D.5643>:
      i = i + 1;
      <D.5547>:
      D.5641 = valid_vals[i];
      if (D.5641 != 0B) goto <D.5546>; else goto <D.5548>;
      <D.5548>:
      D.5645 = *value;
      if (D.5645 != 0) goto <D.5646>; else goto <D.5647>;
      <D.5646>:
      monoeg_g_print ("Unknown trace loglevel: %s\n", value);
      <D.5647>:
    }
  finally
    {
      valid_vals = {CLOBBER};
      valid_ids = {CLOBBER};
    }
}


mono_trace_set_mask_string (const char * value)
{
  char D.5663;
  const char * D.5666;
  long unsigned int D.5667;
  long unsigned int D.5670;
  int D.5671;
  sizetype D.5674;
  const char * D.5675;
  char D.5676;
  <unnamed type> D.5678;
  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.5661>; else goto <D.5662>;
      <D.5661>:
      return;
      <D.5662>:
      tok = value;
      goto <D.5557>;
      <D.5572>:
      D.5663 = *tok;
      if (D.5663 == 44) goto <D.5664>; else goto <D.5665>;
      <D.5664>:
      tok = tok + 1;
      // predicted unlikely by continue predictor.
      goto <D.5557>;
      <D.5665>:
      i = 0;
      goto <D.5570>;
      <D.5569>:
      {
        int len;

        D.5666 = valid_flags[i];
        D.5667 = strlen (D.5666);
        len = (int) D.5667;
        D.5666 = valid_flags[i];
        D.5670 = (long unsigned int) len;
        D.5671 = strncmp (tok, D.5666, D.5670);
        if (D.5671 == 0) goto <D.5672>; else goto <D.5673>;
        <D.5672>:
        D.5674 = (sizetype) len;
        D.5675 = tok + D.5674;
        D.5676 = *D.5675;
        if (D.5676 == 0) goto <D.5668>; else goto <D.5677>;
        <D.5677>:
        D.5674 = (sizetype) len;
        D.5675 = tok + D.5674;
        D.5676 = *D.5675;
        if (D.5676 == 44) goto <D.5668>; else goto <D.5669>;
        <D.5668>:
        D.5678 = valid_masks[i];
        flags = D.5678 | flags;
        D.5674 = (sizetype) len;
        tok = tok + D.5674;
        goto <D.5568>;
        <D.5669>:
        <D.5673>:
      }
      i = i + 1;
      <D.5570>:
      D.5666 = valid_flags[i];
      if (D.5666 != 0B) goto <D.5569>; else goto <D.5568>;
      <D.5568>:
      D.5666 = valid_flags[i];
      if (D.5666 == 0B) goto <D.5679>; else goto <D.5680>;
      <D.5679>:
      monoeg_g_print ("Unknown trace flag: %s\n", tok);
      goto <D.5571>;
      <D.5680>:
      <D.5557>:
      D.5663 = *tok;
      if (D.5663 != 0) goto <D.5572>; else goto <D.5571>;
      <D.5571>:
      mono_trace_set_mask (flags);
    }
  finally
    {
      valid_flags = {CLOBBER};
      valid_masks = {CLOBBER};
    }
}


mono_trace_is_traced (GLogLevelFlags level, MonoTraceMask mask)
{
  gboolean D.5684;
  int iftmp.20;
  <unnamed type> current_level.21;
  <unnamed type> current_mask.22;
  unsigned int D.5691;

  current_level.21 = current_level;
  if (level <= current_level.21) goto <D.5689>; else goto <D.5686>;
  <D.5689>:
  current_mask.22 = current_mask;
  D.5691 = mask & current_mask.22;
  if (D.5691 != 0) goto <D.5692>; else goto <D.5686>;
  <D.5692>:
  iftmp.20 = 1;
  goto <D.5687>;
  <D.5686>:
  iftmp.20 = 0;
  <D.5687>:
  D.5684 = iftmp.20;
  return D.5684;
}