mono_trace_eval_exception (struct MonoClass * klass)
{
  gboolean D.22837;
  struct MonoTraceOperation * D.22838;
  long unsigned int D.22839;
  long unsigned int D.22840;
  <unnamed type> D.22841;
  int D.22523;
  int iftmp.0;
  int D.22519;
  const char[1] * D.22847;
  unsigned char D.22848;
  int D.22849;
  unsigned char D.22850;
  int D.22851;
  const unsigned char * D.22856;
  unsigned char D.22857;
  int D.22858;
  const unsigned char * D.22859;
  unsigned char D.22860;
  int D.22861;
  const unsigned char * D.22866;
  unsigned char D.22867;
  int D.22868;
  const unsigned char * D.22869;
  unsigned char D.22870;
  int D.22871;
  const unsigned char * D.22876;
  unsigned char D.22877;
  int D.22878;
  const unsigned char * D.22879;
  unsigned char D.22880;
  int D.22881;
  void * D.22883;
  unsigned char D.22884;
  int D.22885;
  int D.22532;
  int iftmp.1;
  int D.22528;
  const char[4] * D.22890;
  unsigned char D.22891;
  int D.22892;
  unsigned char D.22893;
  int D.22894;
  const unsigned char * D.22899;
  unsigned char D.22900;
  int D.22901;
  const unsigned char * D.22902;
  unsigned char D.22903;
  int D.22904;
  const unsigned char * D.22909;
  unsigned char D.22910;
  int D.22911;
  const unsigned char * D.22912;
  unsigned char D.22913;
  int D.22914;
  const unsigned char * D.22919;
  unsigned char D.22920;
  int D.22921;
  const unsigned char * D.22922;
  unsigned char D.22923;
  int D.22924;
  void * D.22926;
  int D.22541;
  int iftmp.2;
  int D.22537;
  unsigned char D.22933;
  int D.22934;
  const unsigned char * D.22939;
  unsigned char D.22940;
  int D.22941;
  const unsigned char * D.22946;
  unsigned char D.22947;
  int D.22948;
  const unsigned char * D.22953;
  unsigned char D.22954;
  int D.22955;
  int D.22550;
  const char * D.22958;
  int D.22559;
  const char * D.22959;
  int D.22962;
  int D.22970;
  int include;
  int i;

  include = 0;
  if (klass == 0B) goto <D.22835>; else goto <D.22836>;
  <D.22835>:
  D.22837 = 0;
  return D.22837;
  <D.22836>:
  i = 0;
  goto <D.22563>;
  <D.22562>:
  {
    struct MonoTraceOperation * op;
    int inc;

    D.22838 = trace_spec.ops;
    D.22839 = (long unsigned int) i;
    D.22840 = D.22839 * 24;
    op = D.22838 + D.22840;
    inc = 0;
    D.22841 = op->op;
    switch (D.22841) <default: <D.22561>, case 6: <D.22514>>
    <D.22514>:
    {
      size_t __s1_len;
      size_t __s2_len;

      __s1_len = 0;
      if (__s1_len <= 3) goto <D.22845>; else goto <D.22846>;
      <D.22845>:
      {
        const unsigned char * __s2;
        int __result;

        __s2 = op->data;
        D.22847 = "";
        D.22848 = MEM[(const unsigned char *)D.22847];
        D.22849 = (int) D.22848;
        D.22850 = *__s2;
        D.22851 = (int) D.22850;
        __result = D.22849 - D.22851;
        {
          if (__s1_len != 0) goto <D.22852>; else goto <D.22853>;
          <D.22852>:
          if (__result == 0) goto <D.22854>; else goto <D.22855>;
          <D.22854>:
          D.22856 = &MEM[(void *)"" + 1B];
          D.22857 = *D.22856;
          D.22858 = (int) D.22857;
          D.22859 = __s2 + 1;
          D.22860 = *D.22859;
          D.22861 = (int) D.22860;
          __result = D.22858 - D.22861;
          if (__s1_len > 1) goto <D.22862>; else goto <D.22863>;
          <D.22862>:
          if (__result == 0) goto <D.22864>; else goto <D.22865>;
          <D.22864>:
          D.22866 = &MEM[(void *)"" + 2B];
          D.22867 = *D.22866;
          D.22868 = (int) D.22867;
          D.22869 = __s2 + 2;
          D.22870 = *D.22869;
          D.22871 = (int) D.22870;
          __result = D.22868 - D.22871;
          if (__s1_len > 2) goto <D.22872>; else goto <D.22873>;
          <D.22872>:
          if (__result == 0) goto <D.22874>; else goto <D.22875>;
          <D.22874>:
          D.22876 = &MEM[(void *)"" + 3B];
          D.22877 = *D.22876;
          D.22878 = (int) D.22877;
          D.22879 = __s2 + 3;
          D.22880 = *D.22879;
          D.22881 = (int) D.22880;
          __result = D.22878 - D.22881;
          <D.22875>:
          <D.22873>:
          <D.22865>:
          <D.22863>:
          <D.22855>:
          <D.22853>:
        }
        D.22519 = __result;
      }
      iftmp.0 = D.22519;
      goto <D.22882>;
      <D.22846>:
      D.22883 = op->data;
      D.22884 = MEM[(const unsigned char * {ref-all})D.22883];
      D.22885 = (int) D.22884;
      iftmp.0 = -D.22885;
      <D.22882>:
      D.22523 = iftmp.0;
    }
    if (D.22523 == 0) goto <D.22886>; else goto <D.22842>;
    <D.22886>:
    {
      size_t __s1_len;
      size_t __s2_len;

      __s1_len = 3;
      if (__s1_len <= 3) goto <D.22888>; else goto <D.22889>;
      <D.22888>:
      {
        const unsigned char * __s2;
        int __result;

        __s2 = op->data2;
        D.22890 = "all";
        D.22891 = MEM[(const unsigned char *)D.22890];
        D.22892 = (int) D.22891;
        D.22893 = *__s2;
        D.22894 = (int) D.22893;
        __result = D.22892 - D.22894;
        {
          if (__s1_len != 0) goto <D.22895>; else goto <D.22896>;
          <D.22895>:
          if (__result == 0) goto <D.22897>; else goto <D.22898>;
          <D.22897>:
          D.22899 = &MEM[(void *)"all" + 1B];
          D.22900 = *D.22899;
          D.22901 = (int) D.22900;
          D.22902 = __s2 + 1;
          D.22903 = *D.22902;
          D.22904 = (int) D.22903;
          __result = D.22901 - D.22904;
          if (__s1_len > 1) goto <D.22905>; else goto <D.22906>;
          <D.22905>:
          if (__result == 0) goto <D.22907>; else goto <D.22908>;
          <D.22907>:
          D.22909 = &MEM[(void *)"all" + 2B];
          D.22910 = *D.22909;
          D.22911 = (int) D.22910;
          D.22912 = __s2 + 2;
          D.22913 = *D.22912;
          D.22914 = (int) D.22913;
          __result = D.22911 - D.22914;
          if (__s1_len > 2) goto <D.22915>; else goto <D.22916>;
          <D.22915>:
          if (__result == 0) goto <D.22917>; else goto <D.22918>;
          <D.22917>:
          D.22919 = &MEM[(void *)"all" + 3B];
          D.22920 = *D.22919;
          D.22921 = (int) D.22920;
          D.22922 = __s2 + 3;
          D.22923 = *D.22922;
          D.22924 = (int) D.22923;
          __result = D.22921 - D.22924;
          <D.22918>:
          <D.22916>:
          <D.22908>:
          <D.22906>:
          <D.22898>:
          <D.22896>:
        }
        D.22528 = __result;
      }
      iftmp.1 = D.22528;
      goto <D.22925>;
      <D.22889>:
      D.22926 = op->data2;
      iftmp.1 = __builtin_strcmp ("all", D.22926);
      <D.22925>:
      D.22532 = iftmp.1;
    }
    if (D.22532 == 0) goto <D.22927>; else goto <D.22842>;
    <D.22927>:
    inc = 1;
    goto <D.22843>;
    <D.22842>:
    {
      size_t __s1_len;
      size_t __s2_len;

      __s1_len = 0;
      if (__s1_len <= 3) goto <D.22931>; else goto <D.22932>;
      <D.22931>:
      {
        const unsigned char * __s2;
        int __result;

        __s2 = op->data;
        D.22847 = "";
        D.22848 = MEM[(const unsigned char *)D.22847];
        D.22849 = (int) D.22848;
        D.22933 = *__s2;
        D.22934 = (int) D.22933;
        __result = D.22849 - D.22934;
        {
          if (__s1_len != 0) goto <D.22935>; else goto <D.22936>;
          <D.22935>:
          if (__result == 0) goto <D.22937>; else goto <D.22938>;
          <D.22937>:
          D.22856 = &MEM[(void *)"" + 1B];
          D.22857 = *D.22856;
          D.22858 = (int) D.22857;
          D.22939 = __s2 + 1;
          D.22940 = *D.22939;
          D.22941 = (int) D.22940;
          __result = D.22858 - D.22941;
          if (__s1_len > 1) goto <D.22942>; else goto <D.22943>;
          <D.22942>:
          if (__result == 0) goto <D.22944>; else goto <D.22945>;
          <D.22944>:
          D.22866 = &MEM[(void *)"" + 2B];
          D.22867 = *D.22866;
          D.22868 = (int) D.22867;
          D.22946 = __s2 + 2;
          D.22947 = *D.22946;
          D.22948 = (int) D.22947;
          __result = D.22868 - D.22948;
          if (__s1_len > 2) goto <D.22949>; else goto <D.22950>;
          <D.22949>:
          if (__result == 0) goto <D.22951>; else goto <D.22952>;
          <D.22951>:
          D.22876 = &MEM[(void *)"" + 3B];
          D.22877 = *D.22876;
          D.22878 = (int) D.22877;
          D.22953 = __s2 + 3;
          D.22954 = *D.22953;
          D.22955 = (int) D.22954;
          __result = D.22878 - D.22955;
          <D.22952>:
          <D.22950>:
          <D.22945>:
          <D.22943>:
          <D.22938>:
          <D.22936>:
        }
        D.22537 = __result;
      }
      iftmp.2 = D.22537;
      goto <D.22956>;
      <D.22932>:
      D.22883 = op->data;
      D.22884 = MEM[(const unsigned char * {ref-all})D.22883];
      D.22885 = (int) D.22884;
      iftmp.2 = -D.22885;
      <D.22956>:
      D.22541 = iftmp.2;
    }
    if (D.22541 == 0) goto <D.22928>; else goto <D.22957>;
    <D.22957>:
    {
      size_t __s1_len;
      size_t __s2_len;

      D.22958 = klass->name_space;
      D.22883 = op->data;
      D.22550 = __builtin_strcmp (D.22958, D.22883);
    }
    if (D.22550 == 0) goto <D.22928>; else goto <D.22929>;
    <D.22928>:
    {
      size_t __s1_len;
      size_t __s2_len;

      D.22959 = klass->name;
      D.22926 = op->data2;
      D.22559 = __builtin_strcmp (D.22959, D.22926);
    }
    if (D.22559 == 0) goto <D.22960>; else goto <D.22961>;
    <D.22960>:
    inc = 1;
    <D.22961>:
    <D.22929>:
    <D.22843>:
    goto <D.22560>;
    <D.22561>:
    goto <D.22560>;
    <D.22560>:
    D.22962 = op->exclude;
    if (D.22962 != 0) goto <D.22963>; else goto <D.22964>;
    <D.22963>:
    if (inc != 0) goto <D.22965>; else goto <D.22966>;
    <D.22965>:
    include = 0;
    <D.22966>:
    goto <D.22967>;
    <D.22964>:
    if (inc != 0) goto <D.22968>; else goto <D.22969>;
    <D.22968>:
    include = 1;
    <D.22969>:
    <D.22967>:
  }
  i = i + 1;
  <D.22563>:
  D.22970 = trace_spec.len;
  if (D.22970 > i) goto <D.22562>; else goto <D.22564>;
  <D.22564>:
  D.22837 = include;
  return D.22837;
}


mono_trace_eval (struct MonoMethod * method)
{
  struct MonoTraceOperation * D.22973;
  long unsigned int D.22974;
  long unsigned int D.22975;
  <unnamed type> D.22976;
  struct MonoAssembly * D.22977;
  struct MonoClass * D.22980;
  struct MonoImage * D.22981;
  struct MonoImage * D.22982;
  long unsigned int D.22987;
  long unsigned int D.22988;
  void * D.22990;
  int D.22991;
  int D.22586;
  const char * D.22994;
  int D.22595;
  const char * D.22997;
  void * D.22998;
  int D.22605;
  const char * D.23001;
  int D.22615;
  int D.23007;
  int D.23015;
  gboolean D.23016;
  int include;
  int i;

  include = 0;
  i = 0;
  goto <D.22618>;
  <D.22617>:
  {
    struct MonoTraceOperation * op;
    int inc;

    D.22973 = trace_spec.ops;
    D.22974 = (long unsigned int) i;
    D.22975 = D.22974 * 24;
    op = D.22973 + D.22975;
    inc = 0;
    D.22976 = op->op;
    switch (D.22976) <default: <D.23006>, case 0: <D.22572>, case 1: <D.22574>, case 2: <D.22576>, case 3: <D.22596>, case 4: <D.22577>, case 5: <D.22606>, case 6: <D.22616>, case 7: <D.22575>>
    <D.22572>:
    inc = 1;
    goto <D.22573>;
    <D.22574>:
    D.22977 = trace_spec.assembly;
    if (D.22977 != 0B) goto <D.22978>; else goto <D.22979>;
    <D.22978>:
    D.22980 = method->klass;
    D.22981 = D.22980->image;
    D.22977 = trace_spec.assembly;
    D.22982 = mono_assembly_get_image (D.22977);
    if (D.22981 == D.22982) goto <D.22983>; else goto <D.22984>;
    <D.22983>:
    inc = 1;
    <D.22984>:
    <D.22979>:
    goto <D.22573>;
    <D.22575>:
    D.22987 = BIT_FIELD_REF <*method, 64, 256>;
    D.22988 = D.22987 & 124;
    if (D.22988 == 20) goto <D.22985>; else goto <D.22989>;
    <D.22989>:
    D.22987 = BIT_FIELD_REF <*method, 64, 256>;
    D.22988 = D.22987 & 124;
    if (D.22988 == 24) goto <D.22985>; else goto <D.22986>;
    <D.22985>:
    inc = 1;
    <D.22986>:
    goto <D.22573>;
    <D.22576>:
    D.22990 = op->data;
    D.22991 = mono_method_desc_full_match (D.22990, method);
    if (D.22991 != 0) goto <D.22992>; else goto <D.22993>;
    <D.22992>:
    inc = 1;
    <D.22993>:
    goto <D.22573>;
    <D.22577>:
    {
      size_t __s1_len;
      size_t __s2_len;

      D.22980 = method->klass;
      D.22994 = D.22980->name_space;
      D.22990 = op->data;
      D.22586 = __builtin_strcmp (D.22994, D.22990);
    }
    if (D.22586 == 0) goto <D.22995>; else goto <D.22996>;
    <D.22995>:
    {
      size_t __s1_len;
      size_t __s2_len;

      D.22980 = method->klass;
      D.22997 = D.22980->name;
      D.22998 = op->data2;
      D.22595 = __builtin_strcmp (D.22997, D.22998);
    }
    if (D.22595 == 0) goto <D.22999>; else goto <D.23000>;
    <D.22999>:
    inc = 1;
    <D.23000>:
    <D.22996>:
    goto <D.22573>;
    <D.22596>:
    {
      size_t __s1_len;
      size_t __s2_len;

      D.22980 = method->klass;
      D.22981 = D.22980->image;
      D.23001 = mono_image_get_name (D.22981);
      D.22990 = op->data;
      D.22605 = __builtin_strcmp (D.23001, D.22990);
    }
    if (D.22605 == 0) goto <D.23002>; else goto <D.23003>;
    <D.23002>:
    inc = 1;
    <D.23003>:
    goto <D.22573>;
    <D.22606>:
    {
      size_t __s1_len;
      size_t __s2_len;

      D.22980 = method->klass;
      D.22994 = D.22980->name_space;
      D.22990 = op->data;
      D.22615 = __builtin_strcmp (D.22994, D.22990);
    }
    if (D.22615 == 0) goto <D.23004>; else goto <D.23005>;
    <D.23004>:
    inc = 1;
    <D.23005>:
    <D.22616>:
    goto <D.22573>;
    <D.23006>:
    <D.22573>:
    D.23007 = op->exclude;
    if (D.23007 != 0) goto <D.23008>; else goto <D.23009>;
    <D.23008>:
    if (inc != 0) goto <D.23010>; else goto <D.23011>;
    <D.23010>:
    include = 0;
    <D.23011>:
    goto <D.23012>;
    <D.23009>:
    if (inc != 0) goto <D.23013>; else goto <D.23014>;
    <D.23013>:
    include = 1;
    <D.23014>:
    <D.23012>:
  }
  i = i + 1;
  <D.22618>:
  D.23015 = trace_spec.len;
  if (D.23015 > i) goto <D.22617>; else goto <D.22619>;
  <D.22619>:
  D.23016 = include;
  return D.23016;
}


mono_trace_parse_options (const char * options)
{
  char D.23018;
  void * D.23021;
  struct MonoTraceOperation * D.23022;
  struct MonoTraceSpec * D.23023;
  long unsigned int D.23026;
  long unsigned int D.23027;
  void * D.23028;
  int last_used.3;
  char * p;
  int size;
  int last_used;
  int token;

  try
    {
      p = options;
      size = 1;
      trace_spec.enabled = 1;
      D.23018 = *p;
      if (D.23018 == 0) goto <D.23019>; else goto <D.23020>;
      <D.23019>:
      trace_spec.len = 1;
      D.23021 = monoeg_malloc0 (24);
      trace_spec.ops = D.23021;
      D.23022 = trace_spec.ops;
      D.23022->op = 0;
      D.23023 = &trace_spec;
      return D.23023;
      <D.23020>:
      p = options;
      goto <D.22705>;
      <D.22704>:
      D.23018 = *p;
      if (D.23018 == 44) goto <D.23024>; else goto <D.23025>;
      <D.23024>:
      size = size + 1;
      <D.23025>:
      p = p + 1;
      <D.22705>:
      D.23018 = *p;
      if (D.23018 != 0) goto <D.22704>; else goto <D.22706>;
      <D.22706>:
      D.23026 = (long unsigned int) size;
      D.23027 = D.23026 * 24;
      D.23028 = monoeg_malloc0 (D.23027);
      trace_spec.ops = D.23028;
      input = options;
      last_used = 0;
      goto <D.22707>;
      <D.22708>:
      if (token == 12) goto <D.23029>; else goto <D.23030>;
      <D.23029>:
      D.23023 = 0B;
      return D.23023;
      <D.23030>:
      if (token == 10) goto <D.23031>; else goto <D.23032>;
      <D.23031>:
      // predicted unlikely by continue predictor.
      goto <D.22707>;
      <D.23032>:
      <D.22707>:
      token = get_spec (&last_used);
      if (token != 11) goto <D.22708>; else goto <D.22709>;
      <D.22709>:
      last_used.3 = last_used;
      trace_spec.len = last_used.3;
      cleanup ();
      D.23023 = &trace_spec;
      return D.23023;
    }
  finally
    {
      last_used = {CLOBBER};
    }
}


get_spec (int * last)
{
  struct _IO_FILE * stderr.4;
  int D.23041;
  struct MonoTraceOperation * D.23044;
  int D.23045;
  long unsigned int D.23046;
  long unsigned int D.23047;
  sizetype D.23048;
  struct MonoTraceOperation * D.23049;
  unsigned int token.5;
  unsigned int D.23051;
  char * value.6;
  struct MonoTraceOperation * D.23059;
  gchar * D.23072;
  char * p.7;
  gchar * D.23081;
  gchar * D.23082;
  gchar * D.23084;
  gchar * D.23085;
  MonoTraceOpcode iftmp.8;
  gchar * D.23092;
  int D.23097;
  int token;

  token = get_token ();
  if (token == 8) goto <D.23036>; else goto <D.23037>;
  <D.23036>:
  token = get_spec (last);
  if (token == 8) goto <D.23038>; else goto <D.23039>;
  <D.23038>:
  stderr.4 = stderr;
  fprintf (stderr.4, "Expecting an expression");
  D.23041 = 12;
  return D.23041;
  <D.23039>:
  if (token == 12) goto <D.23042>; else goto <D.23043>;
  <D.23042>:
  D.23041 = token;
  return D.23041;
  <D.23043>:
  D.23044 = trace_spec.ops;
  D.23045 = *last;
  D.23046 = (long unsigned int) D.23045;
  D.23047 = D.23046 * 24;
  D.23048 = D.23047 + 18446744073709551592;
  D.23049 = D.23044 + D.23048;
  D.23049->exclude = 1;
  D.23041 = 10;
  return D.23041;
  <D.23037>:
  token.5 = (unsigned int) token;
  D.23051 = token.5 + 4294967286;
  if (D.23051 <= 2) goto <D.23052>; else goto <D.23053>;
  <D.23052>:
  D.23041 = token;
  return D.23041;
  <D.23053>:
  if (token == 0) goto <D.23054>; else goto <D.23055>;
  <D.23054>:
  {
    struct MonoMethodDesc * desc;

    value.6 = value;
    desc = mono_method_desc_new (value.6, 1);
    if (desc == 0B) goto <D.23057>; else goto <D.23058>;
    <D.23057>:
    stderr.4 = stderr;
    value.6 = value;
    fprintf (stderr.4, "Invalid method name: %s\n", value.6);
    D.23041 = 12;
    return D.23041;
    <D.23058>:
    D.23044 = trace_spec.ops;
    D.23045 = *last;
    D.23046 = (long unsigned int) D.23045;
    D.23047 = D.23046 * 24;
    D.23059 = D.23044 + D.23047;
    D.23059->op = 2;
    D.23044 = trace_spec.ops;
    D.23045 = *last;
    D.23046 = (long unsigned int) D.23045;
    D.23047 = D.23046 * 24;
    D.23059 = D.23044 + D.23047;
    D.23059->data = desc;
  }
  goto <D.23060>;
  <D.23055>:
  if (token == 2) goto <D.23061>; else goto <D.23062>;
  <D.23061>:
  D.23044 = trace_spec.ops;
  D.23045 = *last;
  D.23046 = (long unsigned int) D.23045;
  D.23047 = D.23046 * 24;
  D.23059 = D.23044 + D.23047;
  D.23059->op = 0;
  goto <D.23063>;
  <D.23062>:
  if (token == 3) goto <D.23064>; else goto <D.23065>;
  <D.23064>:
  D.23044 = trace_spec.ops;
  D.23045 = *last;
  D.23046 = (long unsigned int) D.23045;
  D.23047 = D.23046 * 24;
  D.23059 = D.23044 + D.23047;
  D.23059->op = 1;
  goto <D.23066>;
  <D.23065>:
  if (token == 6) goto <D.23067>; else goto <D.23068>;
  <D.23067>:
  D.23044 = trace_spec.ops;
  D.23045 = *last;
  D.23046 = (long unsigned int) D.23045;
  D.23047 = D.23046 * 24;
  D.23059 = D.23044 + D.23047;
  D.23059->op = 7;
  goto <D.23069>;
  <D.23068>:
  if (token == 5) goto <D.23070>; else goto <D.23071>;
  <D.23070>:
  D.23044 = trace_spec.ops;
  D.23045 = *last;
  D.23046 = (long unsigned int) D.23045;
  D.23047 = D.23046 * 24;
  D.23059 = D.23044 + D.23047;
  D.23059->op = 5;
  D.23044 = trace_spec.ops;
  D.23045 = *last;
  D.23046 = (long unsigned int) D.23045;
  D.23047 = D.23046 * 24;
  D.23059 = D.23044 + D.23047;
  value.6 = value;
  D.23072 = monoeg_strdup (value.6);
  D.23059->data = D.23072;
  goto <D.23073>;
  <D.23071>:
  if (token == 1) goto <D.23074>; else goto <D.23077>;
  <D.23077>:
  if (token == 4) goto <D.23074>; else goto <D.23075>;
  <D.23074>:
  {
    char * p;

    value.6 = value;
    p = strrchr (value.6, 46);
    if (p != 0B) goto <D.23078>; else goto <D.23079>;
    <D.23078>:
    p.7 = p;
    p = p.7 + 1;
    *p.7 = 0;
    D.23044 = trace_spec.ops;
    D.23045 = *last;
    D.23046 = (long unsigned int) D.23045;
    D.23047 = D.23046 * 24;
    D.23059 = D.23044 + D.23047;
    value.6 = value;
    D.23081 = monoeg_strdup (value.6);
    D.23059->data = D.23081;
    D.23044 = trace_spec.ops;
    D.23045 = *last;
    D.23046 = (long unsigned int) D.23045;
    D.23047 = D.23046 * 24;
    D.23059 = D.23044 + D.23047;
    D.23082 = monoeg_strdup (p);
    D.23059->data2 = D.23082;
    goto <D.23083>;
    <D.23079>:
    D.23044 = trace_spec.ops;
    D.23045 = *last;
    D.23046 = (long unsigned int) D.23045;
    D.23047 = D.23046 * 24;
    D.23059 = D.23044 + D.23047;
    D.23084 = monoeg_strdup ("");
    D.23059->data = D.23084;
    D.23044 = trace_spec.ops;
    D.23045 = *last;
    D.23046 = (long unsigned int) D.23045;
    D.23047 = D.23046 * 24;
    D.23059 = D.23044 + D.23047;
    value.6 = value;
    D.23085 = monoeg_strdup (value.6);
    D.23059->data2 = D.23085;
    <D.23083>:
    D.23044 = trace_spec.ops;
    D.23045 = *last;
    D.23046 = (long unsigned int) D.23045;
    D.23047 = D.23046 * 24;
    D.23059 = D.23044 + D.23047;
    if (token == 1) goto <D.23087>; else goto <D.23088>;
    <D.23087>:
    iftmp.8 = 4;
    goto <D.23089>;
    <D.23088>:
    iftmp.8 = 6;
    <D.23089>:
    D.23059->op = iftmp.8;
  }
  goto <D.23076>;
  <D.23075>:
  if (token == 7) goto <D.23090>; else goto <D.23091>;
  <D.23090>:
  D.23044 = trace_spec.ops;
  D.23045 = *last;
  D.23046 = (long unsigned int) D.23045;
  D.23047 = D.23046 * 24;
  D.23059 = D.23044 + D.23047;
  D.23059->op = 3;
  D.23044 = trace_spec.ops;
  D.23045 = *last;
  D.23046 = (long unsigned int) D.23045;
  D.23047 = D.23046 * 24;
  D.23059 = D.23044 + D.23047;
  value.6 = value;
  D.23092 = monoeg_strdup (value.6);
  D.23059->data = D.23092;
  goto <D.23093>;
  <D.23091>:
  if (token == 9) goto <D.23094>; else goto <D.23095>;
  <D.23094>:
  trace_spec.enabled = 0;
  goto <D.23096>;
  <D.23095>:
  stderr.4 = stderr;
  fprintf (stderr.4, "Syntax error in trace option specification\n");
  D.23041 = 12;
  return D.23041;
  <D.23096>:
  <D.23093>:
  <D.23076>:
  <D.23073>:
  <D.23069>:
  <D.23066>:
  <D.23063>:
  <D.23060>:
  D.23045 = *last;
  D.23097 = D.23045 + 1;
  *last = D.23097;
  D.23041 = 10;
  return D.23041;
}


get_token ()
{
  char * input.9;
  char * input.10;
  char D.23101;
  int D.23104;
  char D.23107;
  char * input.11;
  int D.23125;
  int D.22660;
  int iftmp.12;
  int D.22659;
  const char[4] * D.23131;
  unsigned char D.23132;
  int D.23133;
  unsigned char D.23134;
  int D.23135;
  const unsigned char * D.23140;
  unsigned char D.23141;
  int D.23142;
  const unsigned char * D.23143;
  unsigned char D.23144;
  int D.23145;
  const unsigned char * D.23150;
  unsigned char D.23151;
  int D.23152;
  const unsigned char * D.23153;
  unsigned char D.23154;
  int D.23155;
  const unsigned char * D.23160;
  unsigned char D.23161;
  int D.23162;
  const unsigned char * D.23163;
  unsigned char D.23164;
  int D.23165;
  char * value.13;
  int D.22669;
  int iftmp.14;
  int D.22668;
  const char[8] * D.23173;
  unsigned char D.23174;
  int D.23175;
  unsigned char D.23176;
  int D.23177;
  const unsigned char * D.23182;
  unsigned char D.23183;
  int D.23184;
  const unsigned char * D.23185;
  unsigned char D.23186;
  int D.23187;
  const unsigned char * D.23192;
  unsigned char D.23193;
  int D.23194;
  const unsigned char * D.23195;
  unsigned char D.23196;
  int D.23197;
  const unsigned char * D.23202;
  unsigned char D.23203;
  int D.23204;
  const unsigned char * D.23205;
  unsigned char D.23206;
  int D.23207;
  int D.22678;
  int iftmp.15;
  int D.22677;
  const char[8] * D.23214;
  unsigned char D.23215;
  int D.23216;
  unsigned char D.23217;
  int D.23218;
  const unsigned char * D.23223;
  unsigned char D.23224;
  int D.23225;
  const unsigned char * D.23226;
  unsigned char D.23227;
  int D.23228;
  const unsigned char * D.23233;
  unsigned char D.23234;
  int D.23235;
  const unsigned char * D.23236;
  unsigned char D.23237;
  int D.23238;
  const unsigned char * D.23243;
  unsigned char D.23244;
  int D.23245;
  const unsigned char * D.23246;
  unsigned char D.23247;
  int D.23248;
  int D.22687;
  int iftmp.16;
  int D.22686;
  const char[9] * D.23255;
  unsigned char D.23256;
  int D.23257;
  unsigned char D.23258;
  int D.23259;
  const unsigned char * D.23264;
  unsigned char D.23265;
  int D.23266;
  const unsigned char * D.23267;
  unsigned char D.23268;
  int D.23269;
  const unsigned char * D.23274;
  unsigned char D.23275;
  int D.23276;
  const unsigned char * D.23277;
  unsigned char D.23278;
  int D.23279;
  const unsigned char * D.23284;
  unsigned char D.23285;
  int D.23286;
  const unsigned char * D.23287;
  unsigned char D.23288;
  int D.23289;
  struct _IO_FILE * stderr.17;

  goto <D.22650>;
  <D.22649>:
  input.9 = input;
  input.10 = input.9 + 1;
  input = input.10;
  <D.22650>:
  input.9 = input;
  D.23101 = *input.9;
  if (D.23101 == 43) goto <D.22649>; else goto <D.22651>;
  <D.22651>:
  input.9 = input;
  D.23101 = *input.9;
  if (D.23101 == 0) goto <D.23102>; else goto <D.23103>;
  <D.23102>:
  D.23104 = 11;
  return D.23104;
  <D.23103>:
  input.9 = input;
  D.23101 = *input.9;
  if (D.23101 == 77) goto <D.23105>; else goto <D.23106>;
  <D.23105>:
  input.9 = input;
  input.10 = input.9 + 1;
  D.23107 = *input.10;
  if (D.23107 == 58) goto <D.23108>; else goto <D.23109>;
  <D.23108>:
  input.9 = input;
  input.11 = input.9 + 2;
  input = input.11;
  get_string ();
  D.23104 = 0;
  return D.23104;
  <D.23109>:
  <D.23106>:
  input.9 = input;
  D.23101 = *input.9;
  if (D.23101 == 78) goto <D.23111>; else goto <D.23112>;
  <D.23111>:
  input.9 = input;
  input.10 = input.9 + 1;
  D.23107 = *input.10;
  if (D.23107 == 58) goto <D.23113>; else goto <D.23114>;
  <D.23113>:
  input.9 = input;
  input.11 = input.9 + 2;
  input = input.11;
  get_string ();
  D.23104 = 5;
  return D.23104;
  <D.23114>:
  <D.23112>:
  input.9 = input;
  D.23101 = *input.9;
  if (D.23101 == 84) goto <D.23115>; else goto <D.23116>;
  <D.23115>:
  input.9 = input;
  input.10 = input.9 + 1;
  D.23107 = *input.10;
  if (D.23107 == 58) goto <D.23117>; else goto <D.23118>;
  <D.23117>:
  input.9 = input;
  input.11 = input.9 + 2;
  input = input.11;
  get_string ();
  D.23104 = 1;
  return D.23104;
  <D.23118>:
  <D.23116>:
  input.9 = input;
  D.23101 = *input.9;
  if (D.23101 == 69) goto <D.23119>; else goto <D.23120>;
  <D.23119>:
  input.9 = input;
  input.10 = input.9 + 1;
  D.23107 = *input.10;
  if (D.23107 == 58) goto <D.23121>; else goto <D.23122>;
  <D.23121>:
  input.9 = input;
  input.11 = input.9 + 2;
  input = input.11;
  get_string ();
  D.23104 = 4;
  return D.23104;
  <D.23122>:
  <D.23120>:
  input.9 = input;
  D.23101 = *input.9;
  if (D.23101 == 45) goto <D.23123>; else goto <D.23124>;
  <D.23123>:
  input.9 = input;
  input.10 = input.9 + 1;
  input = input.10;
  D.23104 = 8;
  return D.23104;
  <D.23124>:
  input.9 = input;
  D.23101 = *input.9;
  D.23125 = is_filenamechar (D.23101);
  if (D.23125 != 0) goto <D.23126>; else goto <D.23127>;
  <D.23126>:
  get_string ();
  {
    size_t __s1_len;
    size_t __s2_len;

    __s2_len = 3;
    if (__s2_len <= 3) goto <D.23129>; else goto <D.23130>;
    <D.23129>:
    {
      const unsigned char * __s2;
      int __result;

      __s2 = value;
      D.23131 = "all";
      D.23132 = MEM[(const unsigned char *)D.23131];
      D.23133 = (int) D.23132;
      D.23134 = *__s2;
      D.23135 = (int) D.23134;
      __result = D.23133 - D.23135;
      {
        if (__s2_len != 0) goto <D.23136>; else goto <D.23137>;
        <D.23136>:
        if (__result == 0) goto <D.23138>; else goto <D.23139>;
        <D.23138>:
        D.23140 = &MEM[(void *)"all" + 1B];
        D.23141 = *D.23140;
        D.23142 = (int) D.23141;
        D.23143 = __s2 + 1;
        D.23144 = *D.23143;
        D.23145 = (int) D.23144;
        __result = D.23142 - D.23145;
        if (__s2_len > 1) goto <D.23146>; else goto <D.23147>;
        <D.23146>:
        if (__result == 0) goto <D.23148>; else goto <D.23149>;
        <D.23148>:
        D.23150 = &MEM[(void *)"all" + 2B];
        D.23151 = *D.23150;
        D.23152 = (int) D.23151;
        D.23153 = __s2 + 2;
        D.23154 = *D.23153;
        D.23155 = (int) D.23154;
        __result = D.23152 - D.23155;
        if (__s2_len > 2) goto <D.23156>; else goto <D.23157>;
        <D.23156>:
        if (__result == 0) goto <D.23158>; else goto <D.23159>;
        <D.23158>:
        D.23160 = &MEM[(void *)"all" + 3B];
        D.23161 = *D.23160;
        D.23162 = (int) D.23161;
        D.23163 = __s2 + 3;
        D.23164 = *D.23163;
        D.23165 = (int) D.23164;
        __result = D.23162 - D.23165;
        <D.23159>:
        <D.23157>:
        <D.23149>:
        <D.23147>:
        <D.23139>:
        <D.23137>:
      }
      D.22659 = __result;
    }
    iftmp.12 = -D.22659;
    goto <D.23166>;
    <D.23130>:
    value.13 = value;
    iftmp.12 = __builtin_strcmp (value.13, "all");
    <D.23166>:
    D.22660 = iftmp.12;
  }
  if (D.22660 == 0) goto <D.23168>; else goto <D.23169>;
  <D.23168>:
  D.23104 = 2;
  return D.23104;
  <D.23169>:
  {
    size_t __s1_len;
    size_t __s2_len;

    __s2_len = 7;
    if (__s2_len <= 3) goto <D.23171>; else goto <D.23172>;
    <D.23171>:
    {
      const unsigned char * __s2;
      int __result;

      __s2 = value;
      D.23173 = "program";
      D.23174 = MEM[(const unsigned char *)D.23173];
      D.23175 = (int) D.23174;
      D.23176 = *__s2;
      D.23177 = (int) D.23176;
      __result = D.23175 - D.23177;
      {
        if (__s2_len != 0) goto <D.23178>; else goto <D.23179>;
        <D.23178>:
        if (__result == 0) goto <D.23180>; else goto <D.23181>;
        <D.23180>:
        D.23182 = &MEM[(void *)"program" + 1B];
        D.23183 = *D.23182;
        D.23184 = (int) D.23183;
        D.23185 = __s2 + 1;
        D.23186 = *D.23185;
        D.23187 = (int) D.23186;
        __result = D.23184 - D.23187;
        if (__s2_len > 1) goto <D.23188>; else goto <D.23189>;
        <D.23188>:
        if (__result == 0) goto <D.23190>; else goto <D.23191>;
        <D.23190>:
        D.23192 = &MEM[(void *)"program" + 2B];
        D.23193 = *D.23192;
        D.23194 = (int) D.23193;
        D.23195 = __s2 + 2;
        D.23196 = *D.23195;
        D.23197 = (int) D.23196;
        __result = D.23194 - D.23197;
        if (__s2_len > 2) goto <D.23198>; else goto <D.23199>;
        <D.23198>:
        if (__result == 0) goto <D.23200>; else goto <D.23201>;
        <D.23200>:
        D.23202 = &MEM[(void *)"program" + 3B];
        D.23203 = *D.23202;
        D.23204 = (int) D.23203;
        D.23205 = __s2 + 3;
        D.23206 = *D.23205;
        D.23207 = (int) D.23206;
        __result = D.23204 - D.23207;
        <D.23201>:
        <D.23199>:
        <D.23191>:
        <D.23189>:
        <D.23181>:
        <D.23179>:
      }
      D.22668 = __result;
    }
    iftmp.14 = -D.22668;
    goto <D.23208>;
    <D.23172>:
    value.13 = value;
    iftmp.14 = __builtin_strcmp (value.13, "program");
    <D.23208>:
    D.22669 = iftmp.14;
  }
  if (D.22669 == 0) goto <D.23209>; else goto <D.23210>;
  <D.23209>:
  D.23104 = 3;
  return D.23104;
  <D.23210>:
  {
    size_t __s1_len;
    size_t __s2_len;

    __s2_len = 7;
    if (__s2_len <= 3) goto <D.23212>; else goto <D.23213>;
    <D.23212>:
    {
      const unsigned char * __s2;
      int __result;

      __s2 = value;
      D.23214 = "wrapper";
      D.23215 = MEM[(const unsigned char *)D.23214];
      D.23216 = (int) D.23215;
      D.23217 = *__s2;
      D.23218 = (int) D.23217;
      __result = D.23216 - D.23218;
      {
        if (__s2_len != 0) goto <D.23219>; else goto <D.23220>;
        <D.23219>:
        if (__result == 0) goto <D.23221>; else goto <D.23222>;
        <D.23221>:
        D.23223 = &MEM[(void *)"wrapper" + 1B];
        D.23224 = *D.23223;
        D.23225 = (int) D.23224;
        D.23226 = __s2 + 1;
        D.23227 = *D.23226;
        D.23228 = (int) D.23227;
        __result = D.23225 - D.23228;
        if (__s2_len > 1) goto <D.23229>; else goto <D.23230>;
        <D.23229>:
        if (__result == 0) goto <D.23231>; else goto <D.23232>;
        <D.23231>:
        D.23233 = &MEM[(void *)"wrapper" + 2B];
        D.23234 = *D.23233;
        D.23235 = (int) D.23234;
        D.23236 = __s2 + 2;
        D.23237 = *D.23236;
        D.23238 = (int) D.23237;
        __result = D.23235 - D.23238;
        if (__s2_len > 2) goto <D.23239>; else goto <D.23240>;
        <D.23239>:
        if (__result == 0) goto <D.23241>; else goto <D.23242>;
        <D.23241>:
        D.23243 = &MEM[(void *)"wrapper" + 3B];
        D.23244 = *D.23243;
        D.23245 = (int) D.23244;
        D.23246 = __s2 + 3;
        D.23247 = *D.23246;
        D.23248 = (int) D.23247;
        __result = D.23245 - D.23248;
        <D.23242>:
        <D.23240>:
        <D.23232>:
        <D.23230>:
        <D.23222>:
        <D.23220>:
      }
      D.22677 = __result;
    }
    iftmp.15 = -D.22677;
    goto <D.23249>;
    <D.23213>:
    value.13 = value;
    iftmp.15 = __builtin_strcmp (value.13, "wrapper");
    <D.23249>:
    D.22678 = iftmp.15;
  }
  if (D.22678 == 0) goto <D.23250>; else goto <D.23251>;
  <D.23250>:
  D.23104 = 6;
  return D.23104;
  <D.23251>:
  {
    size_t __s1_len;
    size_t __s2_len;

    __s2_len = 8;
    if (__s2_len <= 3) goto <D.23253>; else goto <D.23254>;
    <D.23253>:
    {
      const unsigned char * __s2;
      int __result;

      __s2 = value;
      D.23255 = "disabled";
      D.23256 = MEM[(const unsigned char *)D.23255];
      D.23257 = (int) D.23256;
      D.23258 = *__s2;
      D.23259 = (int) D.23258;
      __result = D.23257 - D.23259;
      {
        if (__s2_len != 0) goto <D.23260>; else goto <D.23261>;
        <D.23260>:
        if (__result == 0) goto <D.23262>; else goto <D.23263>;
        <D.23262>:
        D.23264 = &MEM[(void *)"disabled" + 1B];
        D.23265 = *D.23264;
        D.23266 = (int) D.23265;
        D.23267 = __s2 + 1;
        D.23268 = *D.23267;
        D.23269 = (int) D.23268;
        __result = D.23266 - D.23269;
        if (__s2_len > 1) goto <D.23270>; else goto <D.23271>;
        <D.23270>:
        if (__result == 0) goto <D.23272>; else goto <D.23273>;
        <D.23272>:
        D.23274 = &MEM[(void *)"disabled" + 2B];
        D.23275 = *D.23274;
        D.23276 = (int) D.23275;
        D.23277 = __s2 + 2;
        D.23278 = *D.23277;
        D.23279 = (int) D.23278;
        __result = D.23276 - D.23279;
        if (__s2_len > 2) goto <D.23280>; else goto <D.23281>;
        <D.23280>:
        if (__result == 0) goto <D.23282>; else goto <D.23283>;
        <D.23282>:
        D.23284 = &MEM[(void *)"disabled" + 3B];
        D.23285 = *D.23284;
        D.23286 = (int) D.23285;
        D.23287 = __s2 + 3;
        D.23288 = *D.23287;
        D.23289 = (int) D.23288;
        __result = D.23286 - D.23289;
        <D.23283>:
        <D.23281>:
        <D.23273>:
        <D.23271>:
        <D.23263>:
        <D.23261>:
      }
      D.22686 = __result;
    }
    iftmp.16 = -D.22686;
    goto <D.23290>;
    <D.23254>:
    value.13 = value;
    iftmp.16 = __builtin_strcmp (value.13, "disabled");
    <D.23290>:
    D.22687 = iftmp.16;
  }
  if (D.22687 == 0) goto <D.23291>; else goto <D.23292>;
  <D.23291>:
  D.23104 = 9;
  return D.23104;
  <D.23292>:
  D.23104 = 7;
  return D.23104;
  <D.23127>:
  input.9 = input;
  D.23101 = *input.9;
  if (D.23101 == 44) goto <D.23293>; else goto <D.23294>;
  <D.23293>:
  input.9 = input;
  input.10 = input.9 + 1;
  input = input.10;
  D.23104 = 10;
  return D.23104;
  <D.23294>:
  stderr.17 = stderr;
  input.9 = input;
  fprintf (stderr.17, "Syntax error at or around \'%s\'\n", input.9);
  D.23104 = 12;
  return D.23104;
}


is_filenamechar (char p)
{
  char D.23297;
  int D.23300;
  char D.23301;
  char D.23304;

  D.23297 = p + 191;
  if (D.23297 <= 25) goto <D.23298>; else goto <D.23299>;
  <D.23298>:
  D.23300 = 1;
  return D.23300;
  <D.23299>:
  D.23301 = p + 159;
  if (D.23301 <= 25) goto <D.23302>; else goto <D.23303>;
  <D.23302>:
  D.23300 = 1;
  return D.23300;
  <D.23303>:
  D.23304 = p + 208;
  if (D.23304 <= 9) goto <D.23305>; else goto <D.23306>;
  <D.23305>:
  D.23300 = 1;
  return D.23300;
  <D.23306>:
  if (p == 46) goto <D.23307>; else goto <D.23309>;
  <D.23309>:
  if (p == 58) goto <D.23307>; else goto <D.23310>;
  <D.23310>:
  if (p == 95) goto <D.23307>; else goto <D.23311>;
  <D.23311>:
  if (p == 45) goto <D.23307>; else goto <D.23308>;
  <D.23307>:
  D.23300 = 1;
  return D.23300;
  <D.23308>:
  D.23300 = 0;
  return D.23300;
}


get_string ()
{
  char * input.18;
  char * input.19;
  char D.23315;
  int D.23316;
  char * value.20;
  long int input.21;
  long int start.22;
  long int D.23322;
  long int D.23323;
  long unsigned int D.23324;
  void * value.23;
  long unsigned int D.23326;
  sizetype D.23327;
  char * D.23328;
  char * start;

  start = input;
  goto <D.22630>;
  <D.22629>:
  input.18 = input;
  input.19 = input.18 + 1;
  input = input.19;
  <D.22630>:
  input.18 = input;
  D.23315 = *input.18;
  D.23316 = is_filenamechar (D.23315);
  if (D.23316 != 0) goto <D.22629>; else goto <D.22631>;
  <D.22631>:
  value.20 = value;
  if (value.20 != 0B) goto <D.23318>; else goto <D.23319>;
  <D.23318>:
  value.20 = value;
  monoeg_g_free (value.20);
  <D.23319>:
  input.18 = input;
  input.21 = (long int) input.18;
  start.22 = (long int) start;
  D.23322 = input.21 - start.22;
  D.23323 = D.23322 + 1;
  D.23324 = (long unsigned int) D.23323;
  value.23 = monoeg_malloc (D.23324);
  value = value.23;
  value.20 = value;
  input.18 = input;
  input.21 = (long int) input.18;
  start.22 = (long int) start;
  D.23322 = input.21 - start.22;
  D.23326 = (long unsigned int) D.23322;
  strncpy (value.20, start, D.23326);
  value.20 = value;
  input.18 = input;
  input.21 = (long int) input.18;
  start.22 = (long int) start;
  D.23322 = input.21 - start.22;
  D.23327 = (sizetype) D.23322;
  D.23328 = value.20 + D.23327;
  *D.23328 = 0;
}


strncpy (char * restrict __dest, const char * restrict __src, size_t __len)
{
  char * D.23329;
  long unsigned int D.23330;

  D.23330 = __builtin_object_size (__dest, 1);
  D.23329 = __builtin___strncpy_chk (__dest, __src, __len, D.23330);
  return D.23329;
}


monoeg_strdup (const gchar * str)
{
  gchar * D.23334;

  if (str != 0B) goto <D.23332>; else goto <D.23333>;
  <D.23332>:
  D.23334 = __strdup (str);
  return D.23334;
  <D.23333>:
  D.23334 = 0B;
  return D.23334;
}


fprintf (struct FILE * restrict __stream, const char * restrict __fmt)
{
  int D.23336;

  D.23336 = __fprintf_chk (__stream, 1, __fmt, __builtin_va_arg_pack ());
  return D.23336;
}


cleanup ()
{
  char * value.24;

  value.24 = value;
  if (value.24 != 0B) goto <D.23339>; else goto <D.23340>;
  <D.23339>:
  value.24 = value;
  monoeg_g_free (value.24);
  <D.23340>:
}


mono_trace_set_assembly (struct MonoAssembly * assembly)
{
  trace_spec.assembly = assembly;
}


mono_trace_enter_method (struct MonoMethod * method, char * ebp)
{
  int D.23341;
  void * D.23346;
  void * D.23347;
  short unsigned int D.23348;
  int D.23349;
  int D.23350;
  long unsigned int D.23351;
  long unsigned int D.23352;
  long unsigned int D.23353;
  long unsigned int D.23354;
  struct MonoDomain * D.23357;
  void * D.23358;
  void * D.23359;
  gboolean * D.23366;
  gboolean * D.23368;
  struct MonoMethodSignature * D.23369;
  struct MonoType * D.23370;
  int D.23371;
  struct MonoMethodSignature * D.23374;
  struct MonoType * D.23375;
  long unsigned int D.23376;
  long unsigned int D.23377;
  _Bool D.23378;
  long int D.23379;
  long int D.23380;
  void * * D.23383;
  void * D.23384;
  struct MonoMethodSignature * D.23385;
  long unsigned int D.23386;
  long unsigned int D.23387;
  short unsigned int D.23390;
  sizetype D.23391;
  struct MonoClass * D.23392;
  long unsigned int D.23393;
  long unsigned int D.23394;
  void * * D.23397;
  struct MonoVTable * D.23401;
  struct MonoClass * D.23402;
  const char * D.23406;
  const char * D.23407;
  struct MonoDomain * D.23408;
  char * D.23409;
  sizetype D.23411;
  sizetype D.23412;
  sizetype D.23413;
  struct MonoJitArgumentInfo * D.23414;
  short unsigned int D.23415;
  sizetype D.23416;
  short unsigned int D.23417;
  struct MonoMethodSignature * D.23418;
  long unsigned int D.23419;
  long unsigned int D.23420;
  void * * D.23423;
  struct MonoType * D.23425;
  unsigned char D.23426;
  int D.23427;
  signed char D.23428;
  int D.23429;
  short int D.23430;
  int D.23431;
  int D.23432;
  struct MonoVTable * D.23435;
  struct MonoClass * D.23436;
  _Bool D.23437;
  long int D.23438;
  long int D.23439;
  struct MonoClass * D.23448;
  gint32 * D.23451;
  int D.23452;
  struct MonoClass * D.23454;
  struct MonoType * D.23457;
  char * D.23458;
  void * D.23461;
  long int D.23462;
  float D.23463;
  double D.23464;
  double D.23465;
  sizetype D.23466;
  guint8 * D.23467;
  unsigned char D.23468;
  int D.23469;
  struct MonoMethodSignature * D.23470;
  short unsigned int D.23471;
  int D.23472;
  struct _IO_FILE * stdout.25;
  int i;
  int j;
  struct MonoClass * class;
  struct MonoObject * o;
  struct MonoJitArgumentInfo * arg_info;
  struct MonoMethodSignature * sig;
  char * fname;
  struct MonoGenericSharingContext * gsctx;

  gsctx = 0B;
  D.23341 = trace_spec.enabled;
  if (D.23341 == 0) goto <D.23342>; else goto <D.23343>;
  <D.23342>:
  return;
  <D.23343>:
  fname = mono_method_full_name (method, 1);
  indent (1);
  printf ("ENTER: %s(", fname);
  monoeg_g_free (fname);
  if (ebp == 0B) goto <D.23344>; else goto <D.23345>;
  <D.23344>:
  D.23346 = __builtin_return_address (1);
  D.23347 = __builtin_extract_return_addr (D.23346);
  printf (") ip: %p\n", D.23347);
  return;
  <D.23345>:
  sig = mono_method_signature (method);
  D.23348 = sig->param_count;
  D.23349 = (int) D.23348;
  D.23350 = D.23349 + 1;
  D.23351 = (long unsigned int) D.23350;
  D.23352 = D.23351 * 6;
  arg_info = __builtin_alloca (D.23352);
  D.23353 = BIT_FIELD_REF <*method, 64, 256>;
  D.23354 = D.23353 & 4096;
  if (D.23354 != 0) goto <D.23355>; else goto <D.23356>;
  <D.23355>:
  {
    struct MonoJitInfo * ji;

    D.23357 = mono_domain_get ();
    D.23358 = __builtin_return_address (0);
    D.23359 = __builtin_extract_return_addr (D.23358);
    ji = mini_jit_info_table_find (D.23357, D.23359, 0B);
    if (ji != 0B) goto <D.23360>; else goto <D.23361>;
    <D.23360>:
    gsctx = mono_jit_info_get_generic_sharing_context (ji);
    if (gsctx != 0B) goto <D.23364>; else goto <D.23365>;
    <D.23364>:
    D.23366 = gsctx->var_is_vt;
    if (D.23366 != 0B) goto <D.23362>; else goto <D.23367>;
    <D.23367>:
    D.23368 = gsctx->mvar_is_vt;
    if (D.23368 != 0B) goto <D.23362>; else goto <D.23363>;
    <D.23362>:
    printf (") <gsharedvt>\n");
    return;
    <D.23363>:
    <D.23365>:
    <D.23361>:
  }
  <D.23356>:
  D.23348 = sig->param_count;
  D.23349 = (int) D.23348;
  mono_arch_get_argument_info (gsctx, sig, D.23349, arg_info);
  D.23369 = mono_method_signature (method);
  D.23370 = D.23369->ret;
  D.23371 = mono_type_is_struct (D.23370);
  if (D.23371 != 0) goto <D.23372>; else goto <D.23373>;
  <D.23372>:
  D.23374 = mono_method_signature (method);
  D.23375 = D.23374->ret;
  D.23376 = BIT_FIELD_REF <*D.23375, 64, 64>;
  D.23377 = D.23376 & 1073741824;
  D.23378 = D.23377 != 0;
  D.23379 = (long int) D.23378;
  D.23380 = __builtin_expect (D.23379, 0);
  if (D.23380 != 0) goto <D.23381>; else goto <D.23382>;
  <D.23381>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "trace.c", 430, "!mono_method_signature (method)->ret->byref");
  <D.23382>:
  D.23383 = ebp + 8;
  D.23384 = *D.23383;
  printf ("VALUERET:%p, ", D.23384);
  <D.23373>:
  D.23385 = mono_method_signature (method);
  D.23386 = BIT_FIELD_REF <*D.23385, 64, 64>;
  D.23387 = D.23386 & 18014398509481984;
  if (D.23387 != 0) goto <D.23388>; else goto <D.23389>;
  <D.23388>:
  {
    void * * this;

    D.23390 = arg_info->offset;
    D.23391 = (sizetype) D.23390;
    this = ebp + D.23391;
    D.23392 = method->klass;
    D.23393 = BIT_FIELD_REF <*D.23392, 64, 256>;
    D.23394 = D.23393 & 8;
    if (D.23394 != 0) goto <D.23395>; else goto <D.23396>;
    <D.23395>:
    D.23397 = MEM[(void * * *)this];
    printf ("value:%p, ", D.23397);
    goto <D.23398>;
    <D.23396>:
    o = MEM[(struct MonoObject * *)this];
    if (o != 0B) goto <D.23399>; else goto <D.23400>;
    <D.23399>:
    D.23401 = o->vtable;
    class = D.23401->klass;
    D.23402 = mono_defaults.string_class;
    if (D.23402 == class) goto <D.23403>; else goto <D.23404>;
    <D.23403>:
    {
      struct MonoString * s;
      char * as;

      s = o;
      as = string_to_utf8 (s);
      printf ("this:[STRING:%p:%s], ", o, as);
      monoeg_g_free (as);
    }
    goto <D.23405>;
    <D.23404>:
    D.23406 = class->name_space;
    D.23407 = class->name;
    D.23401 = o->vtable;
    D.23408 = D.23401->domain;
    D.23409 = D.23408->friendly_name;
    printf ("this:%p[%s.%s %s], ", o, D.23406, D.23407, D.23409);
    <D.23405>:
    goto <D.23410>;
    <D.23400>:
    printf ("this:NULL, ");
    <D.23410>:
    <D.23398>:
  }
  <D.23389>:
  i = 0;
  goto <D.22777>;
  <D.22776>:
  {
    void * * cpos;
    int size;
    struct MonoType * type;

    D.23411 = (sizetype) i;
    D.23412 = D.23411 + 1;
    D.23413 = D.23412 * 6;
    D.23414 = arg_info + D.23413;
    D.23415 = D.23414->offset;
    D.23416 = (sizetype) D.23415;
    cpos = ebp + D.23416;
    D.23411 = (sizetype) i;
    D.23412 = D.23411 + 1;
    D.23413 = D.23412 * 6;
    D.23414 = arg_info + D.23413;
    D.23417 = D.23414->size;
    size = (int) D.23417;
    D.23418 = mono_method_signature (method);
    type = D.23418->params[i];
    D.23419 = BIT_FIELD_REF <*type, 64, 64>;
    D.23420 = D.23419 & 1073741824;
    if (D.23420 != 0) goto <D.23421>; else goto <D.23422>;
    <D.23421>:
    D.23423 = MEM[(void * * *)cpos];
    printf ("[BYREF:%p], ", D.23423);
    goto <D.23424>;
    <D.23422>:
    D.23425 = mono_type_get_underlying_type (type);
    D.23426 = D.23425->type;
    D.23427 = (int) D.23426;
    switch (D.23427) <default: <D.22775>, case 2: <D.22749>, case 3: <D.22750>, case 4: <D.22751>, case 5: <D.22752>, case 6: <D.22753>, case 7: <D.22754>, case 8: <D.22755>, case 9: <D.22756>, case 10: <D.22767>, case 11: <D.22768>, case 12: <D.22769>, case 13: <D.22770>, case 14: <D.22757>, case 15: <D.22763>, case 17: <D.22771>, case 18: <D.22760>, case 20: <D.22765>, case 24: <D.22746>, case 25: <D.22747>, case 27: <D.22764>, case 28: <D.22761>, case 29: <D.22766>>
    <D.22746>:
    <D.22747>:
    D.23423 = MEM[(void * * *)cpos];
    printf ("%p, ", D.23423);
    goto <D.22748>;
    <D.22749>:
    <D.22750>:
    <D.22751>:
    <D.22752>:
    D.23428 = MEM[(gint8 *)cpos];
    D.23429 = (int) D.23428;
    printf ("%d, ", D.23429);
    goto <D.22748>;
    <D.22753>:
    <D.22754>:
    D.23430 = MEM[(gint16 *)cpos];
    D.23431 = (int) D.23430;
    printf ("%d, ", D.23431);
    goto <D.22748>;
    <D.22755>:
    <D.22756>:
    D.23432 = MEM[(int *)cpos];
    printf ("%d, ", D.23432);
    goto <D.22748>;
    <D.22757>:
    {
      struct MonoString * s;

      s = MEM[(struct MonoString * *)cpos];
      if (s != 0B) goto <D.23433>; else goto <D.23434>;
      <D.23433>:
      {
        char * as;

        D.23435 = MEM[(struct MonoObject *)s].vtable;
        D.23436 = D.23435->klass;
        D.23402 = mono_defaults.string_class;
        D.23437 = D.23436 != D.23402;
        D.23438 = (long int) D.23437;
        D.23439 = __builtin_expect (D.23438, 0);
        if (D.23439 != 0) goto <D.23440>; else goto <D.23441>;
        <D.23440>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "trace.c", 492, "((MonoObject *)s)->vtable->klass == mono_defaults.string_class");
        <D.23441>:
        as = string_to_utf8 (s);
        printf ("[STRING:%p:%s], ", s, as);
        monoeg_g_free (as);
      }
      goto <D.23442>;
      <D.23434>:
      printf ("[STRING:null], ");
      <D.23442>:
      goto <D.22748>;
    }
    <D.22760>:
    <D.22761>:
    o = MEM[(struct MonoObject * *)cpos];
    if (o != 0B) goto <D.23443>; else goto <D.23444>;
    <D.23443>:
    D.23401 = o->vtable;
    class = D.23401->klass;
    D.23402 = mono_defaults.string_class;
    if (D.23402 == class) goto <D.23445>; else goto <D.23446>;
    <D.23445>:
    {
      char * as;

      as = string_to_utf8 (o);
      printf ("[STRING:%p:%s], ", o, as);
      monoeg_g_free (as);
    }
    goto <D.23447>;
    <D.23446>:
    D.23448 = mono_defaults.int32_class;
    if (D.23448 == class) goto <D.23449>; else goto <D.23450>;
    <D.23449>:
    D.23451 = o + 16;
    D.23452 = *D.23451;
    printf ("[INT32:%p:%d], ", o, D.23452);
    goto <D.23453>;
    <D.23450>:
    D.23454 = mono_defaults.monotype_class;
    if (D.23454 == class) goto <D.23455>; else goto <D.23456>;
    <D.23455>:
    D.23457 = MEM[(struct MonoReflectionType *)o].type;
    D.23458 = mono_type_full_name (D.23457);
    printf ("[TYPE:%s], ", D.23458);
    goto <D.23459>;
    <D.23456>:
    D.23406 = class->name_space;
    D.23407 = class->name;
    printf ("[%s.%s:%p], ", D.23406, D.23407, o);
    <D.23459>:
    <D.23453>:
    <D.23447>:
    goto <D.23460>;
    <D.23444>:
    D.23461 = *cpos;
    printf ("%p, ", D.23461);
    <D.23460>:
    goto <D.22748>;
    <D.22763>:
    <D.22764>:
    <D.22765>:
    <D.22766>:
    D.23461 = *cpos;
    printf ("%p, ", D.23461);
    goto <D.22748>;
    <D.22767>:
    <D.22768>:
    D.23462 = MEM[(gint64 *)cpos];
    printf ("0x%016llx, ", D.23462);
    goto <D.22748>;
    <D.22769>:
    D.23463 = MEM[(float *)cpos];
    D.23464 = (double) D.23463;
    printf ("%f, ", D.23464);
    goto <D.22748>;
    <D.22770>:
    D.23465 = MEM[(double *)cpos];
    printf ("%f, ", D.23465);
    goto <D.22748>;
    <D.22771>:
    printf ("[");
    j = 0;
    goto <D.22773>;
    <D.22772>:
    D.23466 = (sizetype) j;
    D.23467 = cpos + D.23466;
    D.23468 = *D.23467;
    D.23469 = (int) D.23468;
    printf ("%02x,", D.23469);
    j = j + 1;
    <D.22773>:
    if (j < size) goto <D.22772>; else goto <D.22774>;
    <D.22774>:
    printf ("], ");
    goto <D.22748>;
    <D.22775>:
    printf ("XX, ");
    <D.22748>:
    <D.23424>:
  }
  i = i + 1;
  <D.22777>:
  D.23470 = mono_method_signature (method);
  D.23471 = D.23470->param_count;
  D.23472 = (int) D.23471;
  if (D.23472 > i) goto <D.22776>; else goto <D.22778>;
  <D.22778>:
  printf (")\n");
  stdout.25 = stdout;
  fflush (stdout.25);
}


indent (int diff)
{
  int indent_level.26;
  int indent_level.27;
  long unsigned int start_time.28;
  long int D.23482;
  long unsigned int start_time.29;
  long unsigned int D.23484;
  void * D.23485;
  double D.23486;

  if (diff < 0) goto <D.23475>; else goto <D.23476>;
  <D.23475>:
  indent_level.26 = indent_level;
  indent_level.27 = indent_level.26 + diff;
  indent_level = indent_level.27;
  <D.23476>:
  start_time.28 = start_time;
  if (start_time.28 == 0) goto <D.23480>; else goto <D.23481>;
  <D.23480>:
  D.23482 = mono_100ns_ticks ();
  start_time.29 = (long unsigned int) D.23482;
  start_time = start_time.29;
  <D.23481>:
  D.23484 = GetCurrentThreadId ();
  D.23485 = (void *) D.23484;
  D.23486 = seconds_since_start ();
  indent_level.26 = indent_level;
  printf ("[%p: %.5f %d] ", D.23485, D.23486, indent_level.26);
  if (diff > 0) goto <D.23487>; else goto <D.23488>;
  <D.23487>:
  indent_level.26 = indent_level;
  indent_level.27 = indent_level.26 + diff;
  indent_level = indent_level.27;
  <D.23488>:
}


seconds_since_start ()
{
  long int D.23489;
  long unsigned int D.23490;
  long unsigned int start_time.30;
  double D.23492;
  double D.23493;
  guint64 diff;

  D.23489 = mono_100ns_ticks ();
  D.23490 = (long unsigned int) D.23489;
  start_time.30 = start_time;
  diff = D.23490 - start_time.30;
  D.23493 = (double) diff;
  D.23492 = D.23493 / 1.0e+7;
  return D.23492;
}


string_to_utf8 (struct MonoString * s)
{
  _Bool D.23495;
  long int D.23496;
  long int D.23497;
  int D.23500;
  char * D.23503;
  mono_unichar2 * D.23504;
  long int D.23505;
  struct GError * error.31;
  char * as;
  struct GError * error;

  try
    {
      error = 0B;
      D.23495 = s == 0B;
      D.23496 = (long int) D.23495;
      D.23497 = __builtin_expect (D.23496, 0);
      if (D.23497 != 0) goto <D.23498>; else goto <D.23499>;
      <D.23498>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "trace.c", 355, "s");
      <D.23499>:
      D.23500 = s->length;
      if (D.23500 == 0) goto <D.23501>; else goto <D.23502>;
      <D.23501>:
      D.23503 = monoeg_strdup ("");
      return D.23503;
      <D.23502>:
      D.23504 = mono_string_chars (s);
      D.23500 = s->length;
      D.23505 = (long int) D.23500;
      as = monoeg_g_utf16_to_utf8 (D.23504, D.23505, 0B, 0B, &error);
      error.31 = error;
      if (error.31 != 0B) goto <D.23507>; else goto <D.23508>;
      <D.23507>:
      error.31 = error;
      monoeg_g_error_free (error.31);
      D.23503 = monoeg_strdup ("<INVALID UTF8>");
      return D.23503;
      <D.23508>:
      D.23503 = as;
      return D.23503;
    }
  finally
    {
      error = {CLOBBER};
    }
}


printf (const char * restrict __fmt)
{
  int D.23511;

  D.23511 = __printf_chk (1, __fmt, __builtin_va_arg_pack ());
  return D.23511;
}


mono_trace_leave_method (struct MonoMethod * method)
{
  int D.23513;
  long unsigned int D.23516;
  long unsigned int D.23517;
  struct MonoDomain * D.23520;
  void * D.23521;
  void * D.23522;
  gboolean * D.23529;
  gboolean * D.23531;
  struct MonoMethodSignature * D.23532;
  unsigned char D.23533;
  int D.23534;
  char * ap.32;
  char * ap.33;
  char * ap.34;
  char * ap.35;
  char * ap.36;
  char * ap.37;
  struct MonoVTable * D.23546;
  struct MonoClass * D.23547;
  struct MonoClass * D.23548;
  _Bool D.23549;
  long int D.23550;
  long int D.23551;
  char * ap.38;
  char * ap.39;
  struct MonoVTable * D.23559;
  struct MonoClass * D.23560;
  struct MonoClass * D.23561;
  guint8 * D.23564;
  unsigned char D.23565;
  int D.23566;
  struct MonoClass * D.23568;
  gint32 * D.23571;
  int D.23572;
  struct MonoClass * D.23574;
  gint64 * D.23577;
  long int D.23578;
  const char * D.23580;
  const char * D.23581;
  char * ap.40;
  char * ap.41;
  char * ap.42;
  char * ap.43;
  char * ap.44;
  char * ap.45;
  char * ap.46;
  char * ap.47;
  struct MonoClass * D.23591;
  long unsigned int D.23592;
  long unsigned int D.23593;
  char * ap.48;
  char * ap.49;
  sizetype D.23598;
  guint8 * D.23599;
  unsigned char D.23600;
  int D.23601;
  struct MonoMethodSignature * D.23603;
  struct MonoType * D.23604;
  unsigned char D.23605;
  int D.23606;
  struct _IO_FILE * stdout.50;
  struct MonoType * type;
  char * fname;
  char * ap;
  struct MonoGenericSharingContext * gsctx;
  void handle_enum = <<< error >>>;

  try
    {
      D.23513 = trace_spec.enabled;
      if (D.23513 == 0) goto <D.23514>; else goto <D.23515>;
      <D.23514>:
      return;
      <D.23515>:
      __builtin_va_start (&ap, 0);
      fname = mono_method_full_name (method, 1);
      indent (-1);
      printf ("LEAVE: %s", fname);
      monoeg_g_free (fname);
      D.23516 = BIT_FIELD_REF <*method, 64, 256>;
      D.23517 = D.23516 & 4096;
      if (D.23517 != 0) goto <D.23518>; else goto <D.23519>;
      <D.23518>:
      {
        struct MonoJitInfo * ji;

        D.23520 = mono_domain_get ();
        D.23521 = __builtin_return_address (0);
        D.23522 = __builtin_extract_return_addr (D.23521);
        ji = mini_jit_info_table_find (D.23520, D.23522, 0B);
        if (ji != 0B) goto <D.23523>; else goto <D.23524>;
        <D.23523>:
        gsctx = mono_jit_info_get_generic_sharing_context (ji);
        if (gsctx != 0B) goto <D.23527>; else goto <D.23528>;
        <D.23527>:
        D.23529 = gsctx->var_is_vt;
        if (D.23529 != 0B) goto <D.23525>; else goto <D.23530>;
        <D.23530>:
        D.23531 = gsctx->mvar_is_vt;
        if (D.23531 != 0B) goto <D.23525>; else goto <D.23526>;
        <D.23525>:
        printf (") <gsharedvt>\n");
        return;
        <D.23526>:
        <D.23528>:
        <D.23524>:
      }
      <D.23519>:
      D.23532 = mono_method_signature (method);
      type = D.23532->ret;
      handle_enum:
      D.23533 = type->type;
      D.23534 = (int) D.23533;
      switch (D.23534) <default: <D.22828>, case 1: <D.22788>, case 2: <D.22790>, case 3: <D.22792>, case 4: <D.22793>, case 5: <D.22794>, case 6: <D.22795>, case 7: <D.22796>, case 8: <D.22797>, case 9: <D.22798>, case 10: <D.22813>, case 11: <D.22815>, case 12: <D.22817>, case 13: <D.22818>, case 14: <D.22802>, case 15: <D.22808>, case 17: <D.22820>, case 18: <D.22805>, case 20: <D.22810>, case 24: <D.22799>, case 25: <D.22800>, case 27: <D.22809>, case 28: <D.22806>, case 29: <D.22811>>
      <D.22788>:
      goto <D.22789>;
      <D.22790>:
      {
        int eax;

        ap.32 = ap;
        ap.33 = ap.32 + 8;
        ap = ap.33;
        eax = MEM[(int *)ap.32];
        if (eax != 0) goto <D.23537>; else goto <D.23538>;
        <D.23537>:
        printf ("TRUE:%d", eax);
        goto <D.23539>;
        <D.23538>:
        printf ("FALSE");
        <D.23539>:
        goto <D.22789>;
      }
      <D.22792>:
      <D.22793>:
      <D.22794>:
      <D.22795>:
      <D.22796>:
      <D.22797>:
      <D.22798>:
      <D.22799>:
      <D.22800>:
      {
        int eax;

        ap.34 = ap;
        ap.35 = ap.34 + 8;
        ap = ap.35;
        eax = MEM[(int *)ap.34];
        printf ("result=%d", eax);
        goto <D.22789>;
      }
      <D.22802>:
      {
        struct MonoString * s;

        ap.36 = ap;
        ap.37 = ap.36 + 8;
        ap = ap.37;
        s = MEM[(struct MonoString * *)ap.36];
        if (s != 0B) goto <D.23544>; else goto <D.23545>;
        <D.23544>:
        {
          char * as;

          D.23546 = MEM[(struct MonoObject *)s].vtable;
          D.23547 = D.23546->klass;
          D.23548 = mono_defaults.string_class;
          D.23549 = D.23547 != D.23548;
          D.23550 = (long int) D.23549;
          D.23551 = __builtin_expect (D.23550, 0);
          if (D.23551 != 0) goto <D.23552>; else goto <D.23553>;
          <D.23552>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "trace.c", 619, "((MonoObject *)s)->vtable->klass == mono_defaults.string_class");
          <D.23553>:
          as = string_to_utf8 (s);
          printf ("[STRING:%p:%s]", s, as);
          monoeg_g_free (as);
        }
        goto <D.23554>;
        <D.23545>:
        printf ("[STRING:null], ");
        <D.23554>:
        goto <D.22789>;
      }
      <D.22805>:
      <D.22806>:
      {
        struct MonoObject * o;

        ap.38 = ap;
        ap.39 = ap.38 + 8;
        ap = ap.39;
        o = MEM[(struct MonoObject * *)ap.38];
        if (o != 0B) goto <D.23557>; else goto <D.23558>;
        <D.23557>:
        D.23559 = o->vtable;
        D.23560 = D.23559->klass;
        D.23561 = mono_defaults.boolean_class;
        if (D.23560 == D.23561) goto <D.23562>; else goto <D.23563>;
        <D.23562>:
        D.23564 = o + 16;
        D.23565 = *D.23564;
        D.23566 = (int) D.23565;
        printf ("[BOOLEAN:%p:%d]", o, D.23566);
        goto <D.23567>;
        <D.23563>:
        D.23559 = o->vtable;
        D.23560 = D.23559->klass;
        D.23568 = mono_defaults.int32_class;
        if (D.23560 == D.23568) goto <D.23569>; else goto <D.23570>;
        <D.23569>:
        D.23571 = o + 16;
        D.23572 = *D.23571;
        printf ("[INT32:%p:%d]", o, D.23572);
        goto <D.23573>;
        <D.23570>:
        D.23559 = o->vtable;
        D.23560 = D.23559->klass;
        D.23574 = mono_defaults.int64_class;
        if (D.23560 == D.23574) goto <D.23575>; else goto <D.23576>;
        <D.23575>:
        D.23577 = o + 16;
        D.23578 = *D.23577;
        printf ("[INT64:%p:%lld]", o, D.23578);
        goto <D.23579>;
        <D.23576>:
        D.23559 = o->vtable;
        D.23560 = D.23559->klass;
        D.23580 = D.23560->name_space;
        D.23559 = o->vtable;
        D.23560 = D.23559->klass;
        D.23581 = D.23560->name;
        printf ("[%s.%s:%p]", D.23580, D.23581, o);
        <D.23579>:
        <D.23573>:
        <D.23567>:
        goto <D.23582>;
        <D.23558>:
        printf ("[OBJECT:%p]", o);
        <D.23582>:
        goto <D.22789>;
      }
      <D.22808>:
      <D.22809>:
      <D.22810>:
      <D.22811>:
      {
        void * p;

        ap.40 = ap;
        ap.41 = ap.40 + 8;
        ap = ap.41;
        p = MEM[(void * *)ap.40];
        printf ("result=%p", p);
        goto <D.22789>;
      }
      <D.22813>:
      {
        gint64 l;

        ap.42 = ap;
        ap.43 = ap.42 + 8;
        ap = ap.43;
        l = MEM[(gint64 *)ap.42];
        printf ("lresult=0x%16llx", l);
        goto <D.22789>;
      }
      <D.22815>:
      {
        gint64 l;

        ap.44 = ap;
        ap.45 = ap.44 + 8;
        ap = ap.45;
        l = MEM[(gint64 *)ap.44];
        printf ("lresult=0x%16llx", l);
        goto <D.22789>;
      }
      <D.22817>:
      <D.22818>:
      {
        double f;

        ap.46 = ap;
        ap.47 = ap.46 + 8;
        ap = ap.47;
        f = MEM[(double *)ap.46];
        printf ("FP=%f", f);
        goto <D.22789>;
      }
      <D.22820>:
      D.23591 = type->data.klass;
      D.23592 = BIT_FIELD_REF <*D.23591, 64, 256>;
      D.23593 = D.23592 & 16;
      if (D.23593 != 0) goto <D.23594>; else goto <D.23595>;
      <D.23594>:
      D.23591 = type->data.klass;
      type = mono_class_enum_basetype (D.23591);
      goto handle_enum;
      <D.23595>:
      {
        guint8 * p;
        int j;
        int size;
        int align;

        try
          {
            ap.48 = ap;
            ap.49 = ap.48 + 8;
            ap = ap.49;
            p = MEM[(void * *)ap.48];
            size = mono_type_size (type, &align);
            printf ("[");
            j = 0;
            goto <D.22826>;
            <D.22825>:
            D.23598 = (sizetype) j;
            D.23599 = p + D.23598;
            D.23600 = *D.23599;
            D.23601 = (int) D.23600;
            printf ("%02x,", D.23601);
            j = j + 1;
            <D.22826>:
            if (p != 0B) goto <D.23602>; else goto <D.22827>;
            <D.23602>:
            if (j < size) goto <D.22825>; else goto <D.22827>;
            <D.22827>:
            printf ("]");
          }
        finally
          {
            align = {CLOBBER};
          }
      }
      goto <D.22789>;
      <D.22828>:
      D.23603 = mono_method_signature (method);
      D.23604 = D.23603->ret;
      D.23605 = D.23604->type;
      D.23606 = (int) D.23605;
      printf ("(unknown return type %x)", D.23606);
      <D.22789>:
      printf ("\n");
      stdout.50 = stdout;
      fflush (stdout.50);
    }
  finally
    {
      ap = {CLOBBER};
    }
}


mono_trace_enable (gboolean enable)
{
  trace_spec.enabled = enable;
}


mono_trace_is_enabled ()
{
  gboolean D.23612;

  D.23612 = trace_spec.enabled;
  return D.23612;
}