mono_trace_cleanup ()
{
  struct GQueue * level_stack.0;
  void * D.4737;
  int D.4738;

  level_stack.0 = level_stack;
  if (level_stack.0 != 0B) goto <D.4735>; else goto <D.4736>;
  <D.4735>:
  goto <D.4654>;
  <D.4653>:
  level_stack.0 = level_stack;
  D.4737 = monoeg_g_queue_pop_head (level_stack.0);
  monoeg_g_free (D.4737);
  <D.4654>:
  level_stack.0 = level_stack;
  D.4738 = monoeg_g_queue_is_empty (level_stack.0);
  if (D.4738 == 0) goto <D.4653>; else goto <D.4655>;
  <D.4655>:
  level_stack.0 = level_stack;
  monoeg_g_queue_free (level_stack.0);
  level_stack = 0B;
  <D.4736>:
}


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

  level_stack.1 = level_stack;
  if (level_stack.1 == 0B) goto <D.4740>; else goto <D.4741>;
  <D.4740>:
  mono_trace_init ();
  <D.4741>:
  current_level.2 = current_level;
  if (level <= current_level.2) goto <D.4743>; else goto <D.4744>;
  <D.4743>:
  current_mask.3 = current_mask;
  D.4746 = mask & current_mask.3;
  if (D.4746 != 0) goto <D.4747>; else goto <D.4748>;
  <D.4747>:
  {
    void * 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.4748>:
  <D.4744>:
}


mono_trace_init ()
{
  struct GQueue * level_stack.6;
  struct GQueue * level_stack.7;
  const gchar * D.4755;
  const gchar * D.4756;

  level_stack.6 = level_stack;
  if (level_stack.6 == 0B) goto <D.4752>; else goto <D.4753>;
  <D.4752>:
  level_stack.7 = monoeg_g_queue_new ();
  level_stack = level_stack.7;
  D.4755 = monoeg_g_getenv ("MONO_LOG_MASK");
  mono_trace_set_mask_string (D.4755);
  D.4756 = monoeg_g_getenv ("MONO_LOG_LEVEL");
  mono_trace_set_level_string (D.4756);
  <D.4753>:
}


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

  level_stack.8 = level_stack;
  if (level_stack.8 == 0B) goto <D.4758>; else goto <D.4759>;
  <D.4758>:
  mono_trace_init ();
  <D.4759>:
  current_level.9 = current_level;
  if (level <= current_level.9) goto <D.4761>; else goto <D.4762>;
  <D.4761>:
  current_mask.10 = current_mask;
  D.4764 = mask & current_mask.10;
  if (D.4764 != 0) goto <D.4765>; else goto <D.4766>;
  <D.4765>:
  mono_log_domain.11 = mono_log_domain;
  monoeg_g_logv (mono_log_domain.11, level, format, args);
  <D.4766>:
  <D.4762>:
}


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

  level_stack.12 = level_stack;
  if (level_stack.12 == 0B) goto <D.4769>; else goto <D.4770>;
  <D.4769>:
  mono_trace_init ();
  <D.4770>:
  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.4772>; else goto <D.4773>;
  <D.4772>:
  mono_trace_init ();
  <D.4773>:
  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.4775>; else goto <D.4776>;
  <D.4775>:
  monoeg_g_log (0B, 4, "%s: cannot use mono_trace_push without calling mono_trace_init first.", &__func__);
  <D.4679>:
  goto <D.4679>;
  <D.4776>:
  {
    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.4782;
  <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.4780>; else goto <D.4781>;
  <D.4780>:
  monoeg_g_log (0B, 4, "%s: cannot use mono_trace_pop without calling mono_trace_init first.", &__func__);
  <D.4685>:
  goto <D.4685>;
  <D.4781>:
  level_stack.17 = level_stack;
  D.4782 = monoeg_g_queue_is_empty (level_stack.17);
  if (D.4782 == 0) goto <D.4783>; else goto <D.4784>;
  <D.4783>:
  {
    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.4784>:
}


mono_trace_set_level_string (const char * value)
{
  int D.4701;
  const char * D.4789;
  <unnamed type> D.4792;
  char D.4793;
  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.4787>; else goto <D.4788>;
      <D.4787>:
      return;
      <D.4788>:
      goto <D.4703>;
      <D.4702>:
      {
        size_t __s1_len;
        size_t __s2_len;

        D.4789 = valid_vals[i];
        D.4701 = __builtin_strcmp (D.4789, value);
      }
      if (D.4701 == 0) goto <D.4790>; else goto <D.4791>;
      <D.4790>:
      D.4792 = valid_ids[i];
      mono_trace_set_level (D.4792);
      return;
      <D.4791>:
      i = i + 1;
      <D.4703>:
      D.4789 = valid_vals[i];
      if (D.4789 != 0B) goto <D.4702>; else goto <D.4704>;
      <D.4704>:
      D.4793 = *value;
      if (D.4793 != 0) goto <D.4794>; else goto <D.4795>;
      <D.4794>:
      monoeg_g_print ("Unknown trace loglevel: %s\n", value);
      <D.4795>:
    }
  finally
    {
      valid_vals = {CLOBBER};
      valid_ids = {CLOBBER};
    }
}


mono_trace_set_mask_string (const char * value)
{
  char D.4810;
  const char * D.4813;
  unsigned int D.4814;
  unsigned int len.20;
  int D.4818;
  sizetype len.21;
  const char * D.4822;
  char D.4823;
  <unnamed type> D.4825;
  int i;
  const char * tok;
  guint32 flags;
  const char * valid_flags[9];
  const MonoTraceMask valid_masks[8];

  try
    {
      flags = 0;
      valid_flags = *$LC8;
      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.4808>; else goto <D.4809>;
      <D.4808>:
      return;
      <D.4809>:
      tok = value;
      goto <D.4713>;
      <D.4728>:
      D.4810 = *tok;
      if (D.4810 == 44) goto <D.4811>; else goto <D.4812>;
      <D.4811>:
      tok = tok + 1;
      // predicted unlikely by continue predictor.
      goto <D.4713>;
      <D.4812>:
      i = 0;
      goto <D.4726>;
      <D.4725>:
      {
        int len;

        D.4813 = valid_flags[i];
        D.4814 = strlen (D.4813);
        len = (int) D.4814;
        D.4813 = valid_flags[i];
        len.20 = (unsigned int) len;
        D.4818 = strncmp (tok, D.4813, len.20);
        if (D.4818 == 0) goto <D.4819>; else goto <D.4820>;
        <D.4819>:
        len.21 = (sizetype) len;
        D.4822 = tok + len.21;
        D.4823 = *D.4822;
        if (D.4823 == 0) goto <D.4815>; else goto <D.4824>;
        <D.4824>:
        len.21 = (sizetype) len;
        D.4822 = tok + len.21;
        D.4823 = *D.4822;
        if (D.4823 == 44) goto <D.4815>; else goto <D.4816>;
        <D.4815>:
        D.4825 = valid_masks[i];
        flags = D.4825 | flags;
        len.21 = (sizetype) len;
        tok = tok + len.21;
        goto <D.4724>;
        <D.4816>:
        <D.4820>:
      }
      i = i + 1;
      <D.4726>:
      D.4813 = valid_flags[i];
      if (D.4813 != 0B) goto <D.4725>; else goto <D.4724>;
      <D.4724>:
      D.4813 = valid_flags[i];
      if (D.4813 == 0B) goto <D.4826>; else goto <D.4827>;
      <D.4826>:
      monoeg_g_print ("Unknown trace flag: %s\n", tok);
      goto <D.4727>;
      <D.4827>:
      <D.4713>:
      D.4810 = *tok;
      if (D.4810 != 0) goto <D.4728>; else goto <D.4727>;
      <D.4727>:
      mono_trace_set_mask (flags);
    }
  finally
    {
      valid_flags = {CLOBBER};
      valid_masks = {CLOBBER};
    }
}


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

  current_level.23 = current_level;
  if (level <= current_level.23) goto <D.4836>; else goto <D.4833>;
  <D.4836>:
  current_mask.24 = current_mask;
  D.4838 = mask & current_mask.24;
  if (D.4838 != 0) goto <D.4839>; else goto <D.4833>;
  <D.4839>:
  iftmp.22 = 1;
  goto <D.4834>;
  <D.4833>:
  iftmp.22 = 0;
  <D.4834>:
  D.4831 = iftmp.22;
  return D.4831;
}