mono_trace_cleanup ()
{
  struct GQueue * level_stack.0;
  void * D.4717;
  int D.4718;

  level_stack.0 = level_stack;
  if (level_stack.0 != 0B) goto <D.4715>; else goto <D.4716>;
  <D.4715>:
  goto <D.4634>;
  <D.4633>:
  level_stack.0 = level_stack;
  D.4717 = monoeg_g_queue_pop_head (level_stack.0);
  monoeg_g_free (D.4717);
  <D.4634>:
  level_stack.0 = level_stack;
  D.4718 = monoeg_g_queue_is_empty (level_stack.0);
  if (D.4718 == 0) goto <D.4633>; else goto <D.4635>;
  <D.4635>:
  level_stack.0 = level_stack;
  monoeg_g_queue_free (level_stack.0);
  level_stack = 0B;
  <D.4716>:
}


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

  level_stack.1 = level_stack;
  if (level_stack.1 == 0B) goto <D.4720>; else goto <D.4721>;
  <D.4720>:
  mono_trace_init ();
  <D.4721>:
  current_level.2 = current_level;
  if (level <= current_level.2) goto <D.4723>; else goto <D.4724>;
  <D.4723>:
  current_mask.3 = current_mask;
  D.4726 = mask & current_mask.3;
  if (D.4726 != 0) goto <D.4727>; else goto <D.4728>;
  <D.4727>:
  {
    char * args;

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


mono_trace_init ()
{
  struct GQueue * level_stack.6;
  struct GQueue * level_stack.7;
  const gchar * D.4735;
  const gchar * D.4736;

  level_stack.6 = level_stack;
  if (level_stack.6 == 0B) goto <D.4732>; else goto <D.4733>;
  <D.4732>:
  level_stack.7 = monoeg_g_queue_new ();
  level_stack = level_stack.7;
  D.4735 = monoeg_g_getenv ("MONO_LOG_MASK");
  mono_trace_set_mask_string (D.4735);
  D.4736 = monoeg_g_getenv ("MONO_LOG_LEVEL");
  mono_trace_set_level_string (D.4736);
  <D.4733>:
}


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.4744;
  const char * mono_log_domain.11;

  level_stack.8 = level_stack;
  if (level_stack.8 == 0B) goto <D.4738>; else goto <D.4739>;
  <D.4738>:
  mono_trace_init ();
  <D.4739>:
  current_level.9 = current_level;
  if (level <= current_level.9) goto <D.4741>; else goto <D.4742>;
  <D.4741>:
  current_mask.10 = current_mask;
  D.4744 = mask & current_mask.10;
  if (D.4744 != 0) goto <D.4745>; else goto <D.4746>;
  <D.4745>:
  mono_log_domain.11 = mono_log_domain;
  monoeg_g_logv (mono_log_domain.11, level, format, args);
  <D.4746>:
  <D.4742>:
}


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

  level_stack.12 = level_stack;
  if (level_stack.12 == 0B) goto <D.4749>; else goto <D.4750>;
  <D.4749>:
  mono_trace_init ();
  <D.4750>:
  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.4752>; else goto <D.4753>;
  <D.4752>:
  mono_trace_init ();
  <D.4753>:
  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.4755>; else goto <D.4756>;
  <D.4755>:
  monoeg_g_log (0B, 4, "%s: cannot use mono_trace_push without calling mono_trace_init first.", &__func__);
  <D.4659>:
  goto <D.4659>;
  <D.4756>:
  {
    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.4762;
  <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.4760>; else goto <D.4761>;
  <D.4760>:
  monoeg_g_log (0B, 4, "%s: cannot use mono_trace_pop without calling mono_trace_init first.", &__func__);
  <D.4665>:
  goto <D.4665>;
  <D.4761>:
  level_stack.17 = level_stack;
  D.4762 = monoeg_g_queue_is_empty (level_stack.17);
  if (D.4762 == 0) goto <D.4763>; else goto <D.4764>;
  <D.4763>:
  {
    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.4764>:
}


mono_trace_set_level_string (const char * value)
{
  int D.4681;
  const char * D.4769;
  <unnamed type> D.4772;
  char D.4773;
  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.4767>; else goto <D.4768>;
      <D.4767>:
      return;
      <D.4768>:
      goto <D.4683>;
      <D.4682>:
      {
        size_t __s1_len;
        size_t __s2_len;

        D.4769 = valid_vals[i];
        D.4681 = __builtin_strcmp (D.4769, value);
      }
      if (D.4681 == 0) goto <D.4770>; else goto <D.4771>;
      <D.4770>:
      D.4772 = valid_ids[i];
      mono_trace_set_level (D.4772);
      return;
      <D.4771>:
      i = i + 1;
      <D.4683>:
      D.4769 = valid_vals[i];
      if (D.4769 != 0B) goto <D.4682>; else goto <D.4684>;
      <D.4684>:
      D.4773 = *value;
      if (D.4773 != 0) goto <D.4774>; else goto <D.4775>;
      <D.4774>:
      monoeg_g_print ("Unknown trace loglevel: %s\n", value);
      <D.4775>:
    }
  finally
    {
      valid_vals = {CLOBBER};
      valid_ids = {CLOBBER};
    }
}


mono_trace_set_mask_string (const char * value)
{
  char D.4781;
  const char * D.4784;
  unsigned int D.4785;
  unsigned int len.20;
  int D.4787;
  sizetype len.21;
  const char * D.4791;
  char D.4792;
  _Bool D.4793;
  _Bool D.4794;
  _Bool D.4795;
  <unnamed type> D.4798;
  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.4779>; else goto <D.4780>;
      <D.4779>:
      return;
      <D.4780>:
      tok = value;
      goto <D.4693>;
      <D.4708>:
      D.4781 = *tok;
      if (D.4781 == 44) goto <D.4782>; else goto <D.4783>;
      <D.4782>:
      tok = tok + 1;
      // predicted unlikely by continue predictor.
      goto <D.4693>;
      <D.4783>:
      i = 0;
      goto <D.4706>;
      <D.4705>:
      {
        int len;

        D.4784 = valid_flags[i];
        D.4785 = strlen (D.4784);
        len = (int) D.4785;
        len.20 = (unsigned int) len;
        D.4784 = valid_flags[i];
        D.4787 = strncmp (tok, D.4784, len.20);
        if (D.4787 == 0) goto <D.4788>; else goto <D.4789>;
        <D.4788>:
        len.21 = (sizetype) len;
        D.4791 = tok + len.21;
        D.4792 = *D.4791;
        D.4793 = D.4792 == 0;
        len.21 = (sizetype) len;
        D.4791 = tok + len.21;
        D.4792 = *D.4791;
        D.4794 = D.4792 == 44;
        D.4795 = D.4793 | D.4794;
        if (D.4795 != 0) goto <D.4796>; else goto <D.4797>;
        <D.4796>:
        D.4798 = valid_masks[i];
        flags = D.4798 | flags;
        len.21 = (sizetype) len;
        tok = tok + len.21;
        goto <D.4704>;
        <D.4797>:
        <D.4789>:
      }
      i = i + 1;
      <D.4706>:
      D.4784 = valid_flags[i];
      if (D.4784 != 0B) goto <D.4705>; else goto <D.4704>;
      <D.4704>:
      D.4784 = valid_flags[i];
      if (D.4784 == 0B) goto <D.4799>; else goto <D.4800>;
      <D.4799>:
      monoeg_g_print ("Unknown trace flag: %s\n", tok);
      goto <D.4707>;
      <D.4800>:
      <D.4693>:
      D.4781 = *tok;
      if (D.4781 != 0) goto <D.4708>; else goto <D.4707>;
      <D.4707>:
      mono_trace_set_mask (flags);
    }
  finally
    {
      valid_flags = {CLOBBER};
      valid_masks = {CLOBBER};
    }
}


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

  current_level.23 = current_level;
  if (level <= current_level.23) goto <D.4809>; else goto <D.4806>;
  <D.4809>:
  current_mask.24 = current_mask;
  D.4811 = mask & current_mask.24;
  if (D.4811 != 0) goto <D.4812>; else goto <D.4806>;
  <D.4812>:
  iftmp.22 = 1;
  goto <D.4807>;
  <D.4806>:
  iftmp.22 = 0;
  <D.4807>:
  D.4804 = iftmp.22;
  return D.4804;
}