mono_trace_cleanup ()
{
  struct GQueue * level_stack.0;
  void * D.7326;
  int D.7327;

  level_stack.0 = level_stack;
  if (level_stack.0 != 0B) goto <D.7324>; else goto <D.7325>;
  <D.7324>:
  goto <D.7241>;
  <D.7240>:
  level_stack.0 = level_stack;
  D.7326 = monoeg_g_queue_pop_head (level_stack.0);
  monoeg_g_free (D.7326);
  <D.7241>:
  level_stack.0 = level_stack;
  D.7327 = monoeg_g_queue_is_empty (level_stack.0);
  if (D.7327 == 0) goto <D.7240>; else goto <D.7242>;
  <D.7242>:
  level_stack.0 = level_stack;
  monoeg_g_queue_free (level_stack.0);
  level_stack = 0B;
  <D.7325>:
}


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.7335;
  const char * mono_log_domain.4;

  level_stack.1 = level_stack;
  if (level_stack.1 == 0B) goto <D.7329>; else goto <D.7330>;
  <D.7329>:
  mono_trace_init ();
  <D.7330>:
  current_level.2 = current_level;
  if (level <= current_level.2) goto <D.7332>; else goto <D.7333>;
  <D.7332>:
  current_mask.3 = current_mask;
  D.7335 = mask & current_mask.3;
  if (D.7335 != 0) goto <D.7336>; else goto <D.7337>;
  <D.7336>:
  {
    struct va_list args;

    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.7337>:
  <D.7333>:
}


mono_trace_init ()
{
  struct GQueue * level_stack.5;
  struct GQueue * level_stack.6;
  const gchar * D.7343;
  const gchar * D.7344;

  level_stack.5 = level_stack;
  if (level_stack.5 == 0B) goto <D.7340>; else goto <D.7341>;
  <D.7340>:
  level_stack.6 = monoeg_g_queue_new ();
  level_stack = level_stack.6;
  D.7343 = monoeg_g_getenv ("MONO_LOG_MASK");
  mono_trace_set_mask_string (D.7343);
  D.7344 = monoeg_g_getenv ("MONO_LOG_LEVEL");
  mono_trace_set_level_string (D.7344);
  <D.7341>:
}


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

  level_stack.7 = level_stack;
  if (level_stack.7 == 0B) goto <D.7346>; else goto <D.7347>;
  <D.7346>:
  mono_trace_init ();
  <D.7347>:
  current_level.8 = current_level;
  if (level <= current_level.8) goto <D.7349>; else goto <D.7350>;
  <D.7349>:
  current_mask.9 = current_mask;
  D.7352 = mask & current_mask.9;
  if (D.7352 != 0) goto <D.7353>; else goto <D.7354>;
  <D.7353>:
  mono_log_domain.10 = mono_log_domain;
  monoeg_g_logv (mono_log_domain.10, level, format, args);
  <D.7354>:
  <D.7350>:
}


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

  level_stack.11 = level_stack;
  if (level_stack.11 == 0B) goto <D.7357>; else goto <D.7358>;
  <D.7357>:
  mono_trace_init ();
  <D.7358>:
  current_level = level;
}


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

  level_stack.12 = level_stack;
  if (level_stack.12 == 0B) goto <D.7360>; else goto <D.7361>;
  <D.7360>:
  mono_trace_init ();
  <D.7361>:
  current_mask = mask;
}


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

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

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


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

  level_stack.16 = level_stack;
  if (level_stack.16 == 0B) goto <D.7368>; else goto <D.7369>;
  <D.7368>:
  monoeg_g_log (0B, 4, "%s: cannot use mono_trace_pop without calling mono_trace_init first.", &__func__);
  <D.7272>:
  goto <D.7272>;
  <D.7369>:
  level_stack.16 = level_stack;
  D.7370 = monoeg_g_queue_is_empty (level_stack.16);
  if (D.7370 == 0) goto <D.7371>; else goto <D.7372>;
  <D.7371>:
  {
    struct MonoLogLevelEntry * entry;

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


mono_trace_set_level_string (const char * value)
{
  int D.7288;
  const char * D.7385;
  <unnamed type> D.7388;
  char D.7389;
  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.7383>; else goto <D.7384>;
      <D.7383>:
      return;
      <D.7384>:
      goto <D.7290>;
      <D.7289>:
      {
        size_t __s1_len;
        size_t __s2_len;

        D.7385 = valid_vals[i];
        D.7288 = __builtin_strcmp (D.7385, value);
      }
      if (D.7288 == 0) goto <D.7386>; else goto <D.7387>;
      <D.7386>:
      D.7388 = valid_ids[i];
      mono_trace_set_level (D.7388);
      return;
      <D.7387>:
      i = i + 1;
      <D.7290>:
      D.7385 = valid_vals[i];
      if (D.7385 != 0B) goto <D.7289>; else goto <D.7291>;
      <D.7291>:
      D.7389 = *value;
      if (D.7389 != 0) goto <D.7390>; else goto <D.7391>;
      <D.7390>:
      monoeg_g_print ("Unknown trace loglevel: %s\n", value);
      <D.7391>:
    }
  finally
    {
      valid_vals = {CLOBBER};
      valid_ids = {CLOBBER};
    }
}


mono_trace_set_mask_string (const char * value)
{
  char D.7407;
  const char * D.7410;
  unsigned int D.7411;
  unsigned int len.19;
  int D.7413;
  sizetype len.20;
  const char * D.7417;
  char D.7418;
  _Bool D.7419;
  _Bool D.7420;
  _Bool D.7421;
  <unnamed type> D.7424;
  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.7405>; else goto <D.7406>;
      <D.7405>:
      return;
      <D.7406>:
      tok = value;
      goto <D.7300>;
      <D.7315>:
      D.7407 = *tok;
      if (D.7407 == 44) goto <D.7408>; else goto <D.7409>;
      <D.7408>:
      tok = tok + 1;
      // predicted unlikely by continue predictor.
      goto <D.7300>;
      <D.7409>:
      i = 0;
      goto <D.7313>;
      <D.7312>:
      {
        int len;

        D.7410 = valid_flags[i];
        D.7411 = strlen (D.7410);
        len = (int) D.7411;
        D.7410 = valid_flags[i];
        len.19 = (unsigned int) len;
        D.7413 = strncmp (tok, D.7410, len.19);
        if (D.7413 == 0) goto <D.7414>; else goto <D.7415>;
        <D.7414>:
        len.20 = (sizetype) len;
        D.7417 = tok + len.20;
        D.7418 = *D.7417;
        D.7419 = D.7418 == 0;
        len.20 = (sizetype) len;
        D.7417 = tok + len.20;
        D.7418 = *D.7417;
        D.7420 = D.7418 == 44;
        D.7421 = D.7419 | D.7420;
        if (D.7421 != 0) goto <D.7422>; else goto <D.7423>;
        <D.7422>:
        D.7424 = valid_masks[i];
        flags = D.7424 | flags;
        len.20 = (sizetype) len;
        tok = tok + len.20;
        goto <D.7311>;
        <D.7423>:
        <D.7415>:
      }
      i = i + 1;
      <D.7313>:
      D.7410 = valid_flags[i];
      if (D.7410 != 0B) goto <D.7312>; else goto <D.7311>;
      <D.7311>:
      D.7410 = valid_flags[i];
      if (D.7410 == 0B) goto <D.7425>; else goto <D.7426>;
      <D.7425>:
      monoeg_g_print ("Unknown trace flag: %s\n", tok);
      goto <D.7314>;
      <D.7426>:
      <D.7300>:
      D.7407 = *tok;
      if (D.7407 != 0) goto <D.7315>; else goto <D.7314>;
      <D.7314>:
      mono_trace_set_mask (flags);
    }
  finally
    {
      valid_flags = {CLOBBER};
      valid_masks = {CLOBBER};
    }
}


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

  current_level.22 = current_level;
  if (level <= current_level.22) goto <D.7435>; else goto <D.7432>;
  <D.7435>:
  current_mask.23 = current_mask;
  D.7437 = mask & current_mask.23;
  if (D.7437 != 0) goto <D.7438>; else goto <D.7432>;
  <D.7438>:
  iftmp.21 = 1;
  goto <D.7433>;
  <D.7432>:
  iftmp.21 = 0;
  <D.7433>:
  D.7430 = iftmp.21;
  return D.7430;
}