mono_trace_cleanup ()
{
  struct GQueue * level_stack.0;
  void * D.5067;
  int D.5068;

  level_stack.0 = level_stack;
  if (level_stack.0 != 0B) goto <D.5065>; else goto <D.5066>;
  <D.5065>:
  goto <D.4984>;
  <D.4983>:
  level_stack.0 = level_stack;
  D.5067 = monoeg_g_queue_pop_head (level_stack.0);
  monoeg_g_free (D.5067);
  <D.4984>:
  level_stack.0 = level_stack;
  D.5068 = monoeg_g_queue_is_empty (level_stack.0);
  if (D.5068 == 0) goto <D.4983>; else goto <D.4985>;
  <D.4985>:
  level_stack.0 = level_stack;
  monoeg_g_queue_free (level_stack.0);
  level_stack = 0B;
  <D.5066>:
}


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

  level_stack.1 = level_stack;
  if (level_stack.1 == 0B) goto <D.5070>; else goto <D.5071>;
  <D.5070>:
  mono_trace_init ();
  <D.5071>:
  current_level.2 = current_level;
  if (level <= current_level.2) goto <D.5073>; else goto <D.5074>;
  <D.5073>:
  current_mask.3 = current_mask;
  D.5076 = mask & current_mask.3;
  if (D.5076 != 0) goto <D.5077>; else goto <D.5078>;
  <D.5077>:
  {
    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.5078>:
  <D.5074>:
}


mono_trace_init ()
{
  struct GQueue * level_stack.5;
  struct GQueue * level_stack.6;
  const gchar * D.5084;
  const gchar * D.5085;

  level_stack.5 = level_stack;
  if (level_stack.5 == 0B) goto <D.5081>; else goto <D.5082>;
  <D.5081>:
  level_stack.6 = monoeg_g_queue_new ();
  level_stack = level_stack.6;
  D.5084 = monoeg_g_getenv ("MONO_LOG_MASK");
  mono_trace_set_mask_string (D.5084);
  D.5085 = monoeg_g_getenv ("MONO_LOG_LEVEL");
  mono_trace_set_level_string (D.5085);
  <D.5082>:
}


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

  level_stack.7 = level_stack;
  if (level_stack.7 == 0B) goto <D.5087>; else goto <D.5088>;
  <D.5087>:
  mono_trace_init ();
  <D.5088>:
  current_level.8 = current_level;
  if (level <= current_level.8) goto <D.5090>; else goto <D.5091>;
  <D.5090>:
  current_mask.9 = current_mask;
  D.5093 = mask & current_mask.9;
  if (D.5093 != 0) goto <D.5094>; else goto <D.5095>;
  <D.5094>:
  mono_log_domain.10 = mono_log_domain;
  monoeg_g_logv (mono_log_domain.10, level, format, args);
  <D.5095>:
  <D.5091>:
}


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

  level_stack.11 = level_stack;
  if (level_stack.11 == 0B) goto <D.5098>; else goto <D.5099>;
  <D.5098>:
  mono_trace_init ();
  <D.5099>:
  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.5101>; else goto <D.5102>;
  <D.5101>:
  mono_trace_init ();
  <D.5102>:
  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.5104>; else goto <D.5105>;
  <D.5104>:
  monoeg_g_log (0B, 4, "%s: cannot use mono_trace_push without calling mono_trace_init first.", &__func__);
  <D.5009>:
  goto <D.5009>;
  <D.5105>:
  {
    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.5111;
  <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.5109>; else goto <D.5110>;
  <D.5109>:
  monoeg_g_log (0B, 4, "%s: cannot use mono_trace_pop without calling mono_trace_init first.", &__func__);
  <D.5015>:
  goto <D.5015>;
  <D.5110>:
  level_stack.16 = level_stack;
  D.5111 = monoeg_g_queue_is_empty (level_stack.16);
  if (D.5111 == 0) goto <D.5112>; else goto <D.5113>;
  <D.5112>:
  {
    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.5113>:
}


mono_trace_set_level_string (const char * value)
{
  int D.5031;
  const char * D.5118;
  <unnamed type> D.5121;
  char D.5122;
  int i;
  const char * valid_vals[7];
  const GLogLevelFlags valid_ids[6];

  try
    {
      i = 0;
      valid_vals[0] = "error";
      valid_vals[1] = "critical";
      valid_vals[2] = "warning";
      valid_vals[3] = "message";
      valid_vals[4] = "info";
      valid_vals[5] = "debug";
      valid_vals[6] = 0B;
      valid_ids[0] = 4;
      valid_ids[1] = 8;
      valid_ids[2] = 16;
      valid_ids[3] = 32;
      valid_ids[4] = 64;
      valid_ids[5] = 128;
      if (value == 0B) goto <D.5116>; else goto <D.5117>;
      <D.5116>:
      return;
      <D.5117>:
      goto <D.5033>;
      <D.5032>:
      {
        size_t __s1_len;
        size_t __s2_len;

        D.5118 = valid_vals[i];
        D.5031 = __builtin_strcmp (D.5118, value);
      }
      if (D.5031 == 0) goto <D.5119>; else goto <D.5120>;
      <D.5119>:
      D.5121 = valid_ids[i];
      mono_trace_set_level (D.5121);
      return;
      <D.5120>:
      i = i + 1;
      <D.5033>:
      D.5118 = valid_vals[i];
      if (D.5118 != 0B) goto <D.5032>; else goto <D.5034>;
      <D.5034>:
      D.5122 = *value;
      if (D.5122 != 0) goto <D.5123>; else goto <D.5124>;
      <D.5123>:
      monoeg_g_print ("Unknown trace loglevel: %s\n", value);
      <D.5124>:
    }
  finally
    {
      valid_vals = {CLOBBER};
      valid_ids = {CLOBBER};
    }
}


mono_trace_set_mask_string (const char * value)
{
  char D.5130;
  const char * D.5133;
  long unsigned int D.5134;
  long unsigned int D.5135;
  int D.5136;
  sizetype D.5139;
  const char * D.5140;
  char D.5141;
  _Bool D.5142;
  _Bool D.5143;
  _Bool D.5144;
  <unnamed type> D.5147;
  int i;
  const char * tok;
  guint32 flags;
  const char * valid_flags[9];
  const MonoTraceMask valid_masks[8];

  try
    {
      flags = 0;
      valid_flags[0] = "asm";
      valid_flags[1] = "type";
      valid_flags[2] = "dll";
      valid_flags[3] = "gc";
      valid_flags[4] = "cfg";
      valid_flags[5] = "aot";
      valid_flags[6] = "security";
      valid_flags[7] = "all";
      valid_flags[8] = 0B;
      valid_masks[0] = 1;
      valid_masks[1] = 2;
      valid_masks[2] = 4;
      valid_masks[3] = 8;
      valid_masks[4] = 16;
      valid_masks[5] = 32;
      valid_masks[6] = 64;
      valid_masks[7] = 127;
      if (value == 0B) goto <D.5128>; else goto <D.5129>;
      <D.5128>:
      return;
      <D.5129>:
      tok = value;
      goto <D.5043>;
      <D.5058>:
      D.5130 = *tok;
      if (D.5130 == 44) goto <D.5131>; else goto <D.5132>;
      <D.5131>:
      tok = tok + 1;
      // predicted unlikely by continue predictor.
      goto <D.5043>;
      <D.5132>:
      i = 0;
      goto <D.5056>;
      <D.5055>:
      {
        int len;

        D.5133 = valid_flags[i];
        D.5134 = strlen (D.5133);
        len = (int) D.5134;
        D.5135 = (long unsigned int) len;
        D.5133 = valid_flags[i];
        D.5136 = strncmp (tok, D.5133, D.5135);
        if (D.5136 == 0) goto <D.5137>; else goto <D.5138>;
        <D.5137>:
        D.5139 = (sizetype) len;
        D.5140 = tok + D.5139;
        D.5141 = *D.5140;
        D.5142 = D.5141 == 0;
        D.5139 = (sizetype) len;
        D.5140 = tok + D.5139;
        D.5141 = *D.5140;
        D.5143 = D.5141 == 44;
        D.5144 = D.5142 | D.5143;
        if (D.5144 != 0) goto <D.5145>; else goto <D.5146>;
        <D.5145>:
        D.5147 = valid_masks[i];
        flags = D.5147 | flags;
        D.5139 = (sizetype) len;
        tok = tok + D.5139;
        goto <D.5054>;
        <D.5146>:
        <D.5138>:
      }
      i = i + 1;
      <D.5056>:
      D.5133 = valid_flags[i];
      if (D.5133 != 0B) goto <D.5055>; else goto <D.5054>;
      <D.5054>:
      D.5133 = valid_flags[i];
      if (D.5133 == 0B) goto <D.5148>; else goto <D.5149>;
      <D.5148>:
      monoeg_g_print ("Unknown trace flag: %s\n", tok);
      goto <D.5057>;
      <D.5149>:
      <D.5043>:
      D.5130 = *tok;
      if (D.5130 != 0) goto <D.5058>; else goto <D.5057>;
      <D.5057>:
      mono_trace_set_mask (flags);
    }
  finally
    {
      valid_flags = {CLOBBER};
      valid_masks = {CLOBBER};
    }
}


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

  current_level.20 = current_level;
  if (level <= current_level.20) goto <D.5158>; else goto <D.5155>;
  <D.5158>:
  current_mask.21 = current_mask;
  D.5160 = mask & current_mask.21;
  if (D.5160 != 0) goto <D.5161>; else goto <D.5155>;
  <D.5161>:
  iftmp.19 = 1;
  goto <D.5156>;
  <D.5155>:
  iftmp.19 = 0;
  <D.5156>:
  D.5153 = iftmp.19;
  return D.5153;
}