mono_trace_eval_exception (struct MonoClass * klass)
{
  gboolean D.22747;
  struct MonoTraceOperation * D.22748;
  long unsigned int D.22749;
  long unsigned int D.22750;
  <unnamed type> D.22751;
  int D.22433;
  int iftmp.0;
  int D.22429;
  const char[1] * D.22757;
  unsigned char D.22758;
  int D.22759;
  unsigned char D.22760;
  int D.22761;
  _Bool D.22762;
  _Bool D.22763;
  _Bool D.22764;
  const unsigned char * D.22767;
  unsigned char D.22768;
  int D.22769;
  const unsigned char * D.22770;
  unsigned char D.22771;
  int D.22772;
  _Bool D.22773;
  _Bool D.22774;
  const unsigned char * D.22777;
  unsigned char D.22778;
  int D.22779;
  const unsigned char * D.22780;
  unsigned char D.22781;
  int D.22782;
  _Bool D.22783;
  _Bool D.22784;
  const unsigned char * D.22787;
  unsigned char D.22788;
  int D.22789;
  const unsigned char * D.22790;
  unsigned char D.22791;
  int D.22792;
  void * D.22794;
  unsigned char D.22795;
  int D.22796;
  int D.22442;
  int iftmp.1;
  int D.22438;
  const char[4] * D.22801;
  unsigned char D.22802;
  int D.22803;
  unsigned char D.22804;
  int D.22805;
  _Bool D.22806;
  _Bool D.22807;
  _Bool D.22808;
  const unsigned char * D.22811;
  unsigned char D.22812;
  int D.22813;
  const unsigned char * D.22814;
  unsigned char D.22815;
  int D.22816;
  _Bool D.22817;
  _Bool D.22818;
  const unsigned char * D.22821;
  unsigned char D.22822;
  int D.22823;
  const unsigned char * D.22824;
  unsigned char D.22825;
  int D.22826;
  _Bool D.22827;
  _Bool D.22828;
  const unsigned char * D.22831;
  unsigned char D.22832;
  int D.22833;
  const unsigned char * D.22834;
  unsigned char D.22835;
  int D.22836;
  void * D.22838;
  int D.22451;
  int iftmp.2;
  int D.22447;
  unsigned char D.22845;
  int D.22846;
  _Bool D.22847;
  _Bool D.22848;
  _Bool D.22849;
  const unsigned char * D.22852;
  unsigned char D.22853;
  int D.22854;
  _Bool D.22855;
  _Bool D.22856;
  const unsigned char * D.22859;
  unsigned char D.22860;
  int D.22861;
  _Bool D.22862;
  _Bool D.22863;
  const unsigned char * D.22866;
  unsigned char D.22867;
  int D.22868;
  int D.22460;
  const char * D.22871;
  int D.22469;
  const char * D.22872;
  int D.22875;
  int D.22883;
  int include;
  int i;

  include = 0;
  if (klass == 0B) goto <D.22745>; else goto <D.22746>;
  <D.22745>:
  D.22747 = 0;
  return D.22747;
  <D.22746>:
  i = 0;
  goto <D.22473>;
  <D.22472>:
  {
    struct MonoTraceOperation * op;
    int inc;

    D.22748 = trace_spec.ops;
    D.22749 = (long unsigned int) i;
    D.22750 = D.22749 * 24;
    op = D.22748 + D.22750;
    inc = 0;
    D.22751 = op->op;
    switch (D.22751) <default: <D.22471>, case 6: <D.22424>>
    <D.22424>:
    {
      size_t __s1_len;
      size_t __s2_len;

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

        __s2 = op->data;
        D.22757 = "";
        D.22758 = MEM[(const unsigned char *)D.22757];
        D.22759 = (int) D.22758;
        D.22760 = *__s2;
        D.22761 = (int) D.22760;
        __result = D.22759 - D.22761;
        {
          D.22762 = __s1_len != 0;
          D.22763 = __result == 0;
          D.22764 = D.22762 & D.22763;
          if (D.22764 != 0) goto <D.22765>; else goto <D.22766>;
          <D.22765>:
          D.22767 = &MEM[(void *)"" + 1B];
          D.22768 = *D.22767;
          D.22769 = (int) D.22768;
          D.22770 = __s2 + 1;
          D.22771 = *D.22770;
          D.22772 = (int) D.22771;
          __result = D.22769 - D.22772;
          D.22773 = __s1_len > 1;
          D.22763 = __result == 0;
          D.22774 = D.22773 & D.22763;
          if (D.22774 != 0) goto <D.22775>; else goto <D.22776>;
          <D.22775>:
          D.22777 = &MEM[(void *)"" + 2B];
          D.22778 = *D.22777;
          D.22779 = (int) D.22778;
          D.22780 = __s2 + 2;
          D.22781 = *D.22780;
          D.22782 = (int) D.22781;
          __result = D.22779 - D.22782;
          D.22783 = __s1_len > 2;
          D.22763 = __result == 0;
          D.22784 = D.22783 & D.22763;
          if (D.22784 != 0) goto <D.22785>; else goto <D.22786>;
          <D.22785>:
          D.22787 = &MEM[(void *)"" + 3B];
          D.22788 = *D.22787;
          D.22789 = (int) D.22788;
          D.22790 = __s2 + 3;
          D.22791 = *D.22790;
          D.22792 = (int) D.22791;
          __result = D.22789 - D.22792;
          <D.22786>:
          <D.22776>:
          <D.22766>:
        }
        D.22429 = __result;
      }
      iftmp.0 = D.22429;
      goto <D.22793>;
      <D.22756>:
      D.22794 = op->data;
      D.22795 = MEM[(const unsigned char * {ref-all})D.22794];
      D.22796 = (int) D.22795;
      iftmp.0 = -D.22796;
      <D.22793>:
      D.22433 = iftmp.0;
    }
    if (D.22433 == 0) goto <D.22797>; else goto <D.22752>;
    <D.22797>:
    {
      size_t __s1_len;
      size_t __s2_len;

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

        __s2 = op->data2;
        D.22801 = "all";
        D.22802 = MEM[(const unsigned char *)D.22801];
        D.22803 = (int) D.22802;
        D.22804 = *__s2;
        D.22805 = (int) D.22804;
        __result = D.22803 - D.22805;
        {
          D.22806 = __s1_len != 0;
          D.22807 = __result == 0;
          D.22808 = D.22806 & D.22807;
          if (D.22808 != 0) goto <D.22809>; else goto <D.22810>;
          <D.22809>:
          D.22811 = &MEM[(void *)"all" + 1B];
          D.22812 = *D.22811;
          D.22813 = (int) D.22812;
          D.22814 = __s2 + 1;
          D.22815 = *D.22814;
          D.22816 = (int) D.22815;
          __result = D.22813 - D.22816;
          D.22817 = __s1_len > 1;
          D.22807 = __result == 0;
          D.22818 = D.22817 & D.22807;
          if (D.22818 != 0) goto <D.22819>; else goto <D.22820>;
          <D.22819>:
          D.22821 = &MEM[(void *)"all" + 2B];
          D.22822 = *D.22821;
          D.22823 = (int) D.22822;
          D.22824 = __s2 + 2;
          D.22825 = *D.22824;
          D.22826 = (int) D.22825;
          __result = D.22823 - D.22826;
          D.22827 = __s1_len > 2;
          D.22807 = __result == 0;
          D.22828 = D.22827 & D.22807;
          if (D.22828 != 0) goto <D.22829>; else goto <D.22830>;
          <D.22829>:
          D.22831 = &MEM[(void *)"all" + 3B];
          D.22832 = *D.22831;
          D.22833 = (int) D.22832;
          D.22834 = __s2 + 3;
          D.22835 = *D.22834;
          D.22836 = (int) D.22835;
          __result = D.22833 - D.22836;
          <D.22830>:
          <D.22820>:
          <D.22810>:
        }
        D.22438 = __result;
      }
      iftmp.1 = D.22438;
      goto <D.22837>;
      <D.22800>:
      D.22838 = op->data2;
      iftmp.1 = __builtin_strcmp ("all", D.22838);
      <D.22837>:
      D.22442 = iftmp.1;
    }
    if (D.22442 == 0) goto <D.22839>; else goto <D.22752>;
    <D.22839>:
    inc = 1;
    goto <D.22753>;
    <D.22752>:
    {
      size_t __s1_len;
      size_t __s2_len;

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

        __s2 = op->data;
        D.22757 = "";
        D.22758 = MEM[(const unsigned char *)D.22757];
        D.22759 = (int) D.22758;
        D.22845 = *__s2;
        D.22846 = (int) D.22845;
        __result = D.22759 - D.22846;
        {
          D.22847 = __s1_len != 0;
          D.22848 = __result == 0;
          D.22849 = D.22847 & D.22848;
          if (D.22849 != 0) goto <D.22850>; else goto <D.22851>;
          <D.22850>:
          D.22767 = &MEM[(void *)"" + 1B];
          D.22768 = *D.22767;
          D.22769 = (int) D.22768;
          D.22852 = __s2 + 1;
          D.22853 = *D.22852;
          D.22854 = (int) D.22853;
          __result = D.22769 - D.22854;
          D.22855 = __s1_len > 1;
          D.22848 = __result == 0;
          D.22856 = D.22855 & D.22848;
          if (D.22856 != 0) goto <D.22857>; else goto <D.22858>;
          <D.22857>:
          D.22777 = &MEM[(void *)"" + 2B];
          D.22778 = *D.22777;
          D.22779 = (int) D.22778;
          D.22859 = __s2 + 2;
          D.22860 = *D.22859;
          D.22861 = (int) D.22860;
          __result = D.22779 - D.22861;
          D.22862 = __s1_len > 2;
          D.22848 = __result == 0;
          D.22863 = D.22862 & D.22848;
          if (D.22863 != 0) goto <D.22864>; else goto <D.22865>;
          <D.22864>:
          D.22787 = &MEM[(void *)"" + 3B];
          D.22788 = *D.22787;
          D.22789 = (int) D.22788;
          D.22866 = __s2 + 3;
          D.22867 = *D.22866;
          D.22868 = (int) D.22867;
          __result = D.22789 - D.22868;
          <D.22865>:
          <D.22858>:
          <D.22851>:
        }
        D.22447 = __result;
      }
      iftmp.2 = D.22447;
      goto <D.22869>;
      <D.22844>:
      D.22794 = op->data;
      D.22795 = MEM[(const unsigned char * {ref-all})D.22794];
      D.22796 = (int) D.22795;
      iftmp.2 = -D.22796;
      <D.22869>:
      D.22451 = iftmp.2;
    }
    if (D.22451 == 0) goto <D.22840>; else goto <D.22870>;
    <D.22870>:
    {
      size_t __s1_len;
      size_t __s2_len;

      D.22794 = op->data;
      D.22871 = klass->name_space;
      D.22460 = __builtin_strcmp (D.22871, D.22794);
    }
    if (D.22460 == 0) goto <D.22840>; else goto <D.22841>;
    <D.22840>:
    {
      size_t __s1_len;
      size_t __s2_len;

      D.22838 = op->data2;
      D.22872 = klass->name;
      D.22469 = __builtin_strcmp (D.22872, D.22838);
    }
    if (D.22469 == 0) goto <D.22873>; else goto <D.22874>;
    <D.22873>:
    inc = 1;
    <D.22874>:
    <D.22841>:
    <D.22753>:
    goto <D.22470>;
    <D.22471>:
    goto <D.22470>;
    <D.22470>:
    D.22875 = op->exclude;
    if (D.22875 != 0) goto <D.22876>; else goto <D.22877>;
    <D.22876>:
    if (inc != 0) goto <D.22878>; else goto <D.22879>;
    <D.22878>:
    include = 0;
    <D.22879>:
    goto <D.22880>;
    <D.22877>:
    if (inc != 0) goto <D.22881>; else goto <D.22882>;
    <D.22881>:
    include = 1;
    <D.22882>:
    <D.22880>:
  }
  i = i + 1;
  <D.22473>:
  D.22883 = trace_spec.len;
  if (D.22883 > i) goto <D.22472>; else goto <D.22474>;
  <D.22474>:
  D.22747 = include;
  return D.22747;
}


mono_trace_eval (struct MonoMethod * method)
{
  struct MonoTraceOperation * D.22886;
  long unsigned int D.22887;
  long unsigned int D.22888;
  <unnamed type> D.22889;
  struct MonoAssembly * D.22890;
  struct MonoClass * D.22893;
  struct MonoImage * D.22894;
  struct MonoImage * D.22895;
  unsigned char D.22898;
  unsigned char D.22899;
  _Bool D.22900;
  _Bool D.22901;
  _Bool D.22902;
  void * D.22905;
  int D.22906;
  int D.22496;
  const char * D.22909;
  int D.22505;
  void * D.22912;
  const char * D.22913;
  int D.22515;
  const char * D.22916;
  int D.22525;
  int D.22922;
  int D.22930;
  gboolean D.22931;
  int include;
  int i;

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

    D.22886 = trace_spec.ops;
    D.22887 = (long unsigned int) i;
    D.22888 = D.22887 * 24;
    op = D.22886 + D.22888;
    inc = 0;
    D.22889 = op->op;
    switch (D.22889) <default: <D.22921>, case 0: <D.22482>, case 1: <D.22484>, case 2: <D.22486>, case 3: <D.22506>, case 4: <D.22487>, case 5: <D.22516>, case 6: <D.22526>, case 7: <D.22485>>
    <D.22482>:
    inc = 1;
    goto <D.22483>;
    <D.22484>:
    D.22890 = trace_spec.assembly;
    if (D.22890 != 0B) goto <D.22891>; else goto <D.22892>;
    <D.22891>:
    D.22893 = method->klass;
    D.22894 = D.22893->image;
    D.22890 = trace_spec.assembly;
    D.22895 = mono_assembly_get_image (D.22890);
    if (D.22894 == D.22895) goto <D.22896>; else goto <D.22897>;
    <D.22896>:
    inc = 1;
    <D.22897>:
    <D.22892>:
    goto <D.22483>;
    <D.22485>:
    D.22898 = BIT_FIELD_REF <*method, 8, 256>;
    D.22899 = D.22898 & 124;
    D.22900 = D.22899 == 20;
    D.22901 = D.22899 == 24;
    D.22902 = D.22900 | D.22901;
    if (D.22902 != 0) goto <D.22903>; else goto <D.22904>;
    <D.22903>:
    inc = 1;
    <D.22904>:
    goto <D.22483>;
    <D.22486>:
    D.22905 = op->data;
    D.22906 = mono_method_desc_full_match (D.22905, method);
    if (D.22906 != 0) goto <D.22907>; else goto <D.22908>;
    <D.22907>:
    inc = 1;
    <D.22908>:
    goto <D.22483>;
    <D.22487>:
    {
      size_t __s1_len;
      size_t __s2_len;

      D.22905 = op->data;
      D.22893 = method->klass;
      D.22909 = D.22893->name_space;
      D.22496 = __builtin_strcmp (D.22909, D.22905);
    }
    if (D.22496 == 0) goto <D.22910>; else goto <D.22911>;
    <D.22910>:
    {
      size_t __s1_len;
      size_t __s2_len;

      D.22912 = op->data2;
      D.22893 = method->klass;
      D.22913 = D.22893->name;
      D.22505 = __builtin_strcmp (D.22913, D.22912);
    }
    if (D.22505 == 0) goto <D.22914>; else goto <D.22915>;
    <D.22914>:
    inc = 1;
    <D.22915>:
    <D.22911>:
    goto <D.22483>;
    <D.22506>:
    {
      size_t __s1_len;
      size_t __s2_len;

      D.22905 = op->data;
      D.22893 = method->klass;
      D.22894 = D.22893->image;
      D.22916 = mono_image_get_name (D.22894);
      D.22515 = __builtin_strcmp (D.22916, D.22905);
    }
    if (D.22515 == 0) goto <D.22917>; else goto <D.22918>;
    <D.22917>:
    inc = 1;
    <D.22918>:
    goto <D.22483>;
    <D.22516>:
    {
      size_t __s1_len;
      size_t __s2_len;

      D.22905 = op->data;
      D.22893 = method->klass;
      D.22909 = D.22893->name_space;
      D.22525 = __builtin_strcmp (D.22909, D.22905);
    }
    if (D.22525 == 0) goto <D.22919>; else goto <D.22920>;
    <D.22919>:
    inc = 1;
    <D.22920>:
    <D.22526>:
    goto <D.22483>;
    <D.22921>:
    <D.22483>:
    D.22922 = op->exclude;
    if (D.22922 != 0) goto <D.22923>; else goto <D.22924>;
    <D.22923>:
    if (inc != 0) goto <D.22925>; else goto <D.22926>;
    <D.22925>:
    include = 0;
    <D.22926>:
    goto <D.22927>;
    <D.22924>:
    if (inc != 0) goto <D.22928>; else goto <D.22929>;
    <D.22928>:
    include = 1;
    <D.22929>:
    <D.22927>:
  }
  i = i + 1;
  <D.22528>:
  D.22930 = trace_spec.len;
  if (D.22930 > i) goto <D.22527>; else goto <D.22529>;
  <D.22529>:
  D.22931 = include;
  return D.22931;
}


mono_trace_parse_options (const char * options)
{
  char D.22933;
  void * D.22936;
  struct MonoTraceOperation * D.22937;
  struct MonoTraceSpec * D.22938;
  long unsigned int D.22941;
  long unsigned int D.22942;
  void * D.22943;
  int last_used.3;
  char * p;
  int size;
  int last_used;
  int token;

  try
    {
      p = options;
      size = 1;
      trace_spec.enabled = 1;
      D.22933 = *p;
      if (D.22933 == 0) goto <D.22934>; else goto <D.22935>;
      <D.22934>:
      trace_spec.len = 1;
      D.22936 = monoeg_malloc0 (24);
      trace_spec.ops = D.22936;
      D.22937 = trace_spec.ops;
      D.22937->op = 0;
      D.22938 = &trace_spec;
      return D.22938;
      <D.22935>:
      p = options;
      goto <D.22615>;
      <D.22614>:
      D.22933 = *p;
      if (D.22933 == 44) goto <D.22939>; else goto <D.22940>;
      <D.22939>:
      size = size + 1;
      <D.22940>:
      p = p + 1;
      <D.22615>:
      D.22933 = *p;
      if (D.22933 != 0) goto <D.22614>; else goto <D.22616>;
      <D.22616>:
      D.22941 = (long unsigned int) size;
      D.22942 = D.22941 * 24;
      D.22943 = monoeg_malloc0 (D.22942);
      trace_spec.ops = D.22943;
      input = options;
      last_used = 0;
      goto <D.22617>;
      <D.22618>:
      if (token == 12) goto <D.22944>; else goto <D.22945>;
      <D.22944>:
      D.22938 = 0B;
      return D.22938;
      <D.22945>:
      if (token == 10) goto <D.22946>; else goto <D.22947>;
      <D.22946>:
      // predicted unlikely by continue predictor.
      goto <D.22617>;
      <D.22947>:
      <D.22617>:
      token = get_spec (&last_used);
      if (token != 11) goto <D.22618>; else goto <D.22619>;
      <D.22619>:
      last_used.3 = last_used;
      trace_spec.len = last_used.3;
      cleanup ();
      D.22938 = &trace_spec;
      return D.22938;
    }
  finally
    {
      last_used = {CLOBBER};
    }
}


get_spec (int * last)
{
  struct _IO_FILE * stderr.4;
  int D.22956;
  struct MonoTraceOperation * D.22959;
  int D.22960;
  long unsigned int D.22961;
  long unsigned int D.22962;
  sizetype D.22963;
  struct MonoTraceOperation * D.22964;
  unsigned int token.5;
  unsigned int D.22966;
  char * value.6;
  struct MonoTraceOperation * D.22974;
  gchar * D.22987;
  _Bool D.22989;
  _Bool D.22990;
  _Bool D.22991;
  char * p.7;
  gchar * D.22997;
  gchar * D.22998;
  gchar * D.23000;
  gchar * D.23001;
  MonoTraceOpcode iftmp.8;
  gchar * D.23009;
  int D.23014;
  int token;

  token = get_token ();
  if (token == 8) goto <D.22951>; else goto <D.22952>;
  <D.22951>:
  token = get_spec (last);
  if (token == 8) goto <D.22953>; else goto <D.22954>;
  <D.22953>:
  stderr.4 = stderr;
  fprintf (stderr.4, "Expecting an expression");
  D.22956 = 12;
  return D.22956;
  <D.22954>:
  if (token == 12) goto <D.22957>; else goto <D.22958>;
  <D.22957>:
  D.22956 = token;
  return D.22956;
  <D.22958>:
  D.22959 = trace_spec.ops;
  D.22960 = *last;
  D.22961 = (long unsigned int) D.22960;
  D.22962 = D.22961 * 24;
  D.22963 = D.22962 + 18446744073709551592;
  D.22964 = D.22959 + D.22963;
  D.22964->exclude = 1;
  D.22956 = 10;
  return D.22956;
  <D.22952>:
  token.5 = (unsigned int) token;
  D.22966 = token.5 + 4294967286;
  if (D.22966 <= 2) goto <D.22967>; else goto <D.22968>;
  <D.22967>:
  D.22956 = token;
  return D.22956;
  <D.22968>:
  if (token == 0) goto <D.22969>; else goto <D.22970>;
  <D.22969>:
  {
    struct MonoMethodDesc * desc;

    value.6 = value;
    desc = mono_method_desc_new (value.6, 1);
    if (desc == 0B) goto <D.22972>; else goto <D.22973>;
    <D.22972>:
    value.6 = value;
    stderr.4 = stderr;
    fprintf (stderr.4, "Invalid method name: %s\n", value.6);
    D.22956 = 12;
    return D.22956;
    <D.22973>:
    D.22959 = trace_spec.ops;
    D.22960 = *last;
    D.22961 = (long unsigned int) D.22960;
    D.22962 = D.22961 * 24;
    D.22974 = D.22959 + D.22962;
    D.22974->op = 2;
    D.22959 = trace_spec.ops;
    D.22960 = *last;
    D.22961 = (long unsigned int) D.22960;
    D.22962 = D.22961 * 24;
    D.22974 = D.22959 + D.22962;
    D.22974->data = desc;
  }
  goto <D.22975>;
  <D.22970>:
  if (token == 2) goto <D.22976>; else goto <D.22977>;
  <D.22976>:
  D.22959 = trace_spec.ops;
  D.22960 = *last;
  D.22961 = (long unsigned int) D.22960;
  D.22962 = D.22961 * 24;
  D.22974 = D.22959 + D.22962;
  D.22974->op = 0;
  goto <D.22978>;
  <D.22977>:
  if (token == 3) goto <D.22979>; else goto <D.22980>;
  <D.22979>:
  D.22959 = trace_spec.ops;
  D.22960 = *last;
  D.22961 = (long unsigned int) D.22960;
  D.22962 = D.22961 * 24;
  D.22974 = D.22959 + D.22962;
  D.22974->op = 1;
  goto <D.22981>;
  <D.22980>:
  if (token == 6) goto <D.22982>; else goto <D.22983>;
  <D.22982>:
  D.22959 = trace_spec.ops;
  D.22960 = *last;
  D.22961 = (long unsigned int) D.22960;
  D.22962 = D.22961 * 24;
  D.22974 = D.22959 + D.22962;
  D.22974->op = 7;
  goto <D.22984>;
  <D.22983>:
  if (token == 5) goto <D.22985>; else goto <D.22986>;
  <D.22985>:
  D.22959 = trace_spec.ops;
  D.22960 = *last;
  D.22961 = (long unsigned int) D.22960;
  D.22962 = D.22961 * 24;
  D.22974 = D.22959 + D.22962;
  D.22974->op = 5;
  D.22959 = trace_spec.ops;
  D.22960 = *last;
  D.22961 = (long unsigned int) D.22960;
  D.22962 = D.22961 * 24;
  D.22974 = D.22959 + D.22962;
  value.6 = value;
  D.22987 = monoeg_strdup (value.6);
  D.22974->data = D.22987;
  goto <D.22988>;
  <D.22986>:
  D.22989 = token == 1;
  D.22990 = token == 4;
  D.22991 = D.22989 | D.22990;
  if (D.22991 != 0) goto <D.22992>; else goto <D.22993>;
  <D.22992>:
  {
    char * p;

    value.6 = value;
    p = strrchr (value.6, 46);
    if (p != 0B) goto <D.22994>; else goto <D.22995>;
    <D.22994>:
    p.7 = p;
    p = p.7 + 1;
    *p.7 = 0;
    D.22959 = trace_spec.ops;
    D.22960 = *last;
    D.22961 = (long unsigned int) D.22960;
    D.22962 = D.22961 * 24;
    D.22974 = D.22959 + D.22962;
    value.6 = value;
    D.22997 = monoeg_strdup (value.6);
    D.22974->data = D.22997;
    D.22959 = trace_spec.ops;
    D.22960 = *last;
    D.22961 = (long unsigned int) D.22960;
    D.22962 = D.22961 * 24;
    D.22974 = D.22959 + D.22962;
    D.22998 = monoeg_strdup (p);
    D.22974->data2 = D.22998;
    goto <D.22999>;
    <D.22995>:
    D.22959 = trace_spec.ops;
    D.22960 = *last;
    D.22961 = (long unsigned int) D.22960;
    D.22962 = D.22961 * 24;
    D.22974 = D.22959 + D.22962;
    D.23000 = monoeg_strdup ("");
    D.22974->data = D.23000;
    D.22959 = trace_spec.ops;
    D.22960 = *last;
    D.22961 = (long unsigned int) D.22960;
    D.22962 = D.22961 * 24;
    D.22974 = D.22959 + D.22962;
    value.6 = value;
    D.23001 = monoeg_strdup (value.6);
    D.22974->data2 = D.23001;
    <D.22999>:
    D.22959 = trace_spec.ops;
    D.22960 = *last;
    D.22961 = (long unsigned int) D.22960;
    D.22962 = D.22961 * 24;
    D.22974 = D.22959 + D.22962;
    if (token == 1) goto <D.23003>; else goto <D.23004>;
    <D.23003>:
    iftmp.8 = 4;
    goto <D.23005>;
    <D.23004>:
    iftmp.8 = 6;
    <D.23005>:
    D.22974->op = iftmp.8;
  }
  goto <D.23006>;
  <D.22993>:
  if (token == 7) goto <D.23007>; else goto <D.23008>;
  <D.23007>:
  D.22959 = trace_spec.ops;
  D.22960 = *last;
  D.22961 = (long unsigned int) D.22960;
  D.22962 = D.22961 * 24;
  D.22974 = D.22959 + D.22962;
  D.22974->op = 3;
  D.22959 = trace_spec.ops;
  D.22960 = *last;
  D.22961 = (long unsigned int) D.22960;
  D.22962 = D.22961 * 24;
  D.22974 = D.22959 + D.22962;
  value.6 = value;
  D.23009 = monoeg_strdup (value.6);
  D.22974->data = D.23009;
  goto <D.23010>;
  <D.23008>:
  if (token == 9) goto <D.23011>; else goto <D.23012>;
  <D.23011>:
  trace_spec.enabled = 0;
  goto <D.23013>;
  <D.23012>:
  stderr.4 = stderr;
  fprintf (stderr.4, "Syntax error in trace option specification\n");
  D.22956 = 12;
  return D.22956;
  <D.23013>:
  <D.23010>:
  <D.23006>:
  <D.22988>:
  <D.22984>:
  <D.22981>:
  <D.22978>:
  <D.22975>:
  D.22960 = *last;
  D.23014 = D.22960 + 1;
  *last = D.23014;
  D.22956 = 10;
  return D.22956;
}


get_token ()
{
  char * input.9;
  char * input.10;
  char D.23018;
  int D.23021;
  char D.23024;
  char * input.11;
  int D.23042;
  int D.23043;
  int D.22570;
  int iftmp.12;
  int D.22569;
  const char[4] * D.23049;
  unsigned char D.23050;
  int D.23051;
  unsigned char D.23052;
  int D.23053;
  _Bool D.23054;
  _Bool D.23055;
  _Bool D.23056;
  const unsigned char * D.23059;
  unsigned char D.23060;
  int D.23061;
  const unsigned char * D.23062;
  unsigned char D.23063;
  int D.23064;
  _Bool D.23065;
  _Bool D.23066;
  const unsigned char * D.23069;
  unsigned char D.23070;
  int D.23071;
  const unsigned char * D.23072;
  unsigned char D.23073;
  int D.23074;
  _Bool D.23075;
  _Bool D.23076;
  const unsigned char * D.23079;
  unsigned char D.23080;
  int D.23081;
  const unsigned char * D.23082;
  unsigned char D.23083;
  int D.23084;
  char * value.13;
  int D.22579;
  int iftmp.14;
  int D.22578;
  const char[8] * D.23092;
  unsigned char D.23093;
  int D.23094;
  unsigned char D.23095;
  int D.23096;
  _Bool D.23097;
  _Bool D.23098;
  _Bool D.23099;
  const unsigned char * D.23102;
  unsigned char D.23103;
  int D.23104;
  const unsigned char * D.23105;
  unsigned char D.23106;
  int D.23107;
  _Bool D.23108;
  _Bool D.23109;
  const unsigned char * D.23112;
  unsigned char D.23113;
  int D.23114;
  const unsigned char * D.23115;
  unsigned char D.23116;
  int D.23117;
  _Bool D.23118;
  _Bool D.23119;
  const unsigned char * D.23122;
  unsigned char D.23123;
  int D.23124;
  const unsigned char * D.23125;
  unsigned char D.23126;
  int D.23127;
  int D.22588;
  int iftmp.15;
  int D.22587;
  const char[8] * D.23134;
  unsigned char D.23135;
  int D.23136;
  unsigned char D.23137;
  int D.23138;
  _Bool D.23139;
  _Bool D.23140;
  _Bool D.23141;
  const unsigned char * D.23144;
  unsigned char D.23145;
  int D.23146;
  const unsigned char * D.23147;
  unsigned char D.23148;
  int D.23149;
  _Bool D.23150;
  _Bool D.23151;
  const unsigned char * D.23154;
  unsigned char D.23155;
  int D.23156;
  const unsigned char * D.23157;
  unsigned char D.23158;
  int D.23159;
  _Bool D.23160;
  _Bool D.23161;
  const unsigned char * D.23164;
  unsigned char D.23165;
  int D.23166;
  const unsigned char * D.23167;
  unsigned char D.23168;
  int D.23169;
  int D.22597;
  int iftmp.16;
  int D.22596;
  const char[9] * D.23176;
  unsigned char D.23177;
  int D.23178;
  unsigned char D.23179;
  int D.23180;
  _Bool D.23181;
  _Bool D.23182;
  _Bool D.23183;
  const unsigned char * D.23186;
  unsigned char D.23187;
  int D.23188;
  const unsigned char * D.23189;
  unsigned char D.23190;
  int D.23191;
  _Bool D.23192;
  _Bool D.23193;
  const unsigned char * D.23196;
  unsigned char D.23197;
  int D.23198;
  const unsigned char * D.23199;
  unsigned char D.23200;
  int D.23201;
  _Bool D.23202;
  _Bool D.23203;
  const unsigned char * D.23206;
  unsigned char D.23207;
  int D.23208;
  const unsigned char * D.23209;
  unsigned char D.23210;
  int D.23211;
  struct _IO_FILE * stderr.17;

  goto <D.22560>;
  <D.22559>:
  input.9 = input;
  input.10 = input.9 + 1;
  input = input.10;
  <D.22560>:
  input.9 = input;
  D.23018 = *input.9;
  if (D.23018 == 43) goto <D.22559>; else goto <D.22561>;
  <D.22561>:
  input.9 = input;
  D.23018 = *input.9;
  if (D.23018 == 0) goto <D.23019>; else goto <D.23020>;
  <D.23019>:
  D.23021 = 11;
  return D.23021;
  <D.23020>:
  input.9 = input;
  D.23018 = *input.9;
  if (D.23018 == 77) goto <D.23022>; else goto <D.23023>;
  <D.23022>:
  input.9 = input;
  input.10 = input.9 + 1;
  D.23024 = *input.10;
  if (D.23024 == 58) goto <D.23025>; else goto <D.23026>;
  <D.23025>:
  input.9 = input;
  input.11 = input.9 + 2;
  input = input.11;
  get_string ();
  D.23021 = 0;
  return D.23021;
  <D.23026>:
  <D.23023>:
  input.9 = input;
  D.23018 = *input.9;
  if (D.23018 == 78) goto <D.23028>; else goto <D.23029>;
  <D.23028>:
  input.9 = input;
  input.10 = input.9 + 1;
  D.23024 = *input.10;
  if (D.23024 == 58) goto <D.23030>; else goto <D.23031>;
  <D.23030>:
  input.9 = input;
  input.11 = input.9 + 2;
  input = input.11;
  get_string ();
  D.23021 = 5;
  return D.23021;
  <D.23031>:
  <D.23029>:
  input.9 = input;
  D.23018 = *input.9;
  if (D.23018 == 84) goto <D.23032>; else goto <D.23033>;
  <D.23032>:
  input.9 = input;
  input.10 = input.9 + 1;
  D.23024 = *input.10;
  if (D.23024 == 58) goto <D.23034>; else goto <D.23035>;
  <D.23034>:
  input.9 = input;
  input.11 = input.9 + 2;
  input = input.11;
  get_string ();
  D.23021 = 1;
  return D.23021;
  <D.23035>:
  <D.23033>:
  input.9 = input;
  D.23018 = *input.9;
  if (D.23018 == 69) goto <D.23036>; else goto <D.23037>;
  <D.23036>:
  input.9 = input;
  input.10 = input.9 + 1;
  D.23024 = *input.10;
  if (D.23024 == 58) goto <D.23038>; else goto <D.23039>;
  <D.23038>:
  input.9 = input;
  input.11 = input.9 + 2;
  input = input.11;
  get_string ();
  D.23021 = 4;
  return D.23021;
  <D.23039>:
  <D.23037>:
  input.9 = input;
  D.23018 = *input.9;
  if (D.23018 == 45) goto <D.23040>; else goto <D.23041>;
  <D.23040>:
  input.9 = input;
  input.10 = input.9 + 1;
  input = input.10;
  D.23021 = 8;
  return D.23021;
  <D.23041>:
  input.9 = input;
  D.23018 = *input.9;
  D.23042 = (int) D.23018;
  D.23043 = is_filenamechar (D.23042);
  if (D.23043 != 0) goto <D.23044>; else goto <D.23045>;
  <D.23044>:
  get_string ();
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = value;
      D.23049 = "all";
      D.23050 = MEM[(const unsigned char *)D.23049];
      D.23051 = (int) D.23050;
      D.23052 = *__s2;
      D.23053 = (int) D.23052;
      __result = D.23051 - D.23053;
      {
        D.23054 = __s2_len != 0;
        D.23055 = __result == 0;
        D.23056 = D.23054 & D.23055;
        if (D.23056 != 0) goto <D.23057>; else goto <D.23058>;
        <D.23057>:
        D.23059 = &MEM[(void *)"all" + 1B];
        D.23060 = *D.23059;
        D.23061 = (int) D.23060;
        D.23062 = __s2 + 1;
        D.23063 = *D.23062;
        D.23064 = (int) D.23063;
        __result = D.23061 - D.23064;
        D.23065 = __s2_len > 1;
        D.23055 = __result == 0;
        D.23066 = D.23065 & D.23055;
        if (D.23066 != 0) goto <D.23067>; else goto <D.23068>;
        <D.23067>:
        D.23069 = &MEM[(void *)"all" + 2B];
        D.23070 = *D.23069;
        D.23071 = (int) D.23070;
        D.23072 = __s2 + 2;
        D.23073 = *D.23072;
        D.23074 = (int) D.23073;
        __result = D.23071 - D.23074;
        D.23075 = __s2_len > 2;
        D.23055 = __result == 0;
        D.23076 = D.23075 & D.23055;
        if (D.23076 != 0) goto <D.23077>; else goto <D.23078>;
        <D.23077>:
        D.23079 = &MEM[(void *)"all" + 3B];
        D.23080 = *D.23079;
        D.23081 = (int) D.23080;
        D.23082 = __s2 + 3;
        D.23083 = *D.23082;
        D.23084 = (int) D.23083;
        __result = D.23081 - D.23084;
        <D.23078>:
        <D.23068>:
        <D.23058>:
      }
      D.22569 = __result;
    }
    iftmp.12 = -D.22569;
    goto <D.23085>;
    <D.23048>:
    value.13 = value;
    iftmp.12 = __builtin_strcmp (value.13, "all");
    <D.23085>:
    D.22570 = iftmp.12;
  }
  if (D.22570 == 0) goto <D.23087>; else goto <D.23088>;
  <D.23087>:
  D.23021 = 2;
  return D.23021;
  <D.23088>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = value;
      D.23092 = "program";
      D.23093 = MEM[(const unsigned char *)D.23092];
      D.23094 = (int) D.23093;
      D.23095 = *__s2;
      D.23096 = (int) D.23095;
      __result = D.23094 - D.23096;
      {
        D.23097 = __s2_len != 0;
        D.23098 = __result == 0;
        D.23099 = D.23097 & D.23098;
        if (D.23099 != 0) goto <D.23100>; else goto <D.23101>;
        <D.23100>:
        D.23102 = &MEM[(void *)"program" + 1B];
        D.23103 = *D.23102;
        D.23104 = (int) D.23103;
        D.23105 = __s2 + 1;
        D.23106 = *D.23105;
        D.23107 = (int) D.23106;
        __result = D.23104 - D.23107;
        D.23108 = __s2_len > 1;
        D.23098 = __result == 0;
        D.23109 = D.23108 & D.23098;
        if (D.23109 != 0) goto <D.23110>; else goto <D.23111>;
        <D.23110>:
        D.23112 = &MEM[(void *)"program" + 2B];
        D.23113 = *D.23112;
        D.23114 = (int) D.23113;
        D.23115 = __s2 + 2;
        D.23116 = *D.23115;
        D.23117 = (int) D.23116;
        __result = D.23114 - D.23117;
        D.23118 = __s2_len > 2;
        D.23098 = __result == 0;
        D.23119 = D.23118 & D.23098;
        if (D.23119 != 0) goto <D.23120>; else goto <D.23121>;
        <D.23120>:
        D.23122 = &MEM[(void *)"program" + 3B];
        D.23123 = *D.23122;
        D.23124 = (int) D.23123;
        D.23125 = __s2 + 3;
        D.23126 = *D.23125;
        D.23127 = (int) D.23126;
        __result = D.23124 - D.23127;
        <D.23121>:
        <D.23111>:
        <D.23101>:
      }
      D.22578 = __result;
    }
    iftmp.14 = -D.22578;
    goto <D.23128>;
    <D.23091>:
    value.13 = value;
    iftmp.14 = __builtin_strcmp (value.13, "program");
    <D.23128>:
    D.22579 = iftmp.14;
  }
  if (D.22579 == 0) goto <D.23129>; else goto <D.23130>;
  <D.23129>:
  D.23021 = 3;
  return D.23021;
  <D.23130>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

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

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

      __s2 = value;
      D.23176 = "disabled";
      D.23177 = MEM[(const unsigned char *)D.23176];
      D.23178 = (int) D.23177;
      D.23179 = *__s2;
      D.23180 = (int) D.23179;
      __result = D.23178 - D.23180;
      {
        D.23181 = __s2_len != 0;
        D.23182 = __result == 0;
        D.23183 = D.23181 & D.23182;
        if (D.23183 != 0) goto <D.23184>; else goto <D.23185>;
        <D.23184>:
        D.23186 = &MEM[(void *)"disabled" + 1B];
        D.23187 = *D.23186;
        D.23188 = (int) D.23187;
        D.23189 = __s2 + 1;
        D.23190 = *D.23189;
        D.23191 = (int) D.23190;
        __result = D.23188 - D.23191;
        D.23192 = __s2_len > 1;
        D.23182 = __result == 0;
        D.23193 = D.23192 & D.23182;
        if (D.23193 != 0) goto <D.23194>; else goto <D.23195>;
        <D.23194>:
        D.23196 = &MEM[(void *)"disabled" + 2B];
        D.23197 = *D.23196;
        D.23198 = (int) D.23197;
        D.23199 = __s2 + 2;
        D.23200 = *D.23199;
        D.23201 = (int) D.23200;
        __result = D.23198 - D.23201;
        D.23202 = __s2_len > 2;
        D.23182 = __result == 0;
        D.23203 = D.23202 & D.23182;
        if (D.23203 != 0) goto <D.23204>; else goto <D.23205>;
        <D.23204>:
        D.23206 = &MEM[(void *)"disabled" + 3B];
        D.23207 = *D.23206;
        D.23208 = (int) D.23207;
        D.23209 = __s2 + 3;
        D.23210 = *D.23209;
        D.23211 = (int) D.23210;
        __result = D.23208 - D.23211;
        <D.23205>:
        <D.23195>:
        <D.23185>:
      }
      D.22596 = __result;
    }
    iftmp.16 = -D.22596;
    goto <D.23212>;
    <D.23175>:
    value.13 = value;
    iftmp.16 = __builtin_strcmp (value.13, "disabled");
    <D.23212>:
    D.22597 = iftmp.16;
  }
  if (D.22597 == 0) goto <D.23213>; else goto <D.23214>;
  <D.23213>:
  D.23021 = 9;
  return D.23021;
  <D.23214>:
  D.23021 = 7;
  return D.23021;
  <D.23045>:
  input.9 = input;
  D.23018 = *input.9;
  if (D.23018 == 44) goto <D.23215>; else goto <D.23216>;
  <D.23215>:
  input.9 = input;
  input.10 = input.9 + 1;
  input = input.10;
  D.23021 = 10;
  return D.23021;
  <D.23216>:
  input.9 = input;
  stderr.17 = stderr;
  fprintf (stderr.17, "Syntax error at or around \'%s\'\n", input.9);
  D.23021 = 12;
  return D.23021;
}


is_filenamechar (char p)
{
  unsigned char p.18;
  unsigned char D.23220;
  int D.23223;
  unsigned char D.23224;
  unsigned char D.23227;
  _Bool D.23232;
  _Bool D.23233;
  _Bool D.23234;
  _Bool D.23236;
  _Bool D.23237;
  _Bool D.23238;

  p.18 = (unsigned char) p;
  D.23220 = p.18 + 191;
  if (D.23220 <= 25) goto <D.23221>; else goto <D.23222>;
  <D.23221>:
  D.23223 = 1;
  return D.23223;
  <D.23222>:
  p.18 = (unsigned char) p;
  D.23224 = p.18 + 159;
  if (D.23224 <= 25) goto <D.23225>; else goto <D.23226>;
  <D.23225>:
  D.23223 = 1;
  return D.23223;
  <D.23226>:
  p.18 = (unsigned char) p;
  D.23227 = p.18 + 208;
  if (D.23227 <= 9) goto <D.23228>; else goto <D.23229>;
  <D.23228>:
  D.23223 = 1;
  return D.23223;
  <D.23229>:
  D.23232 = p == 46;
  D.23233 = p == 58;
  D.23234 = D.23232 | D.23233;
  if (D.23234 != 0) goto <D.23230>; else goto <D.23235>;
  <D.23235>:
  D.23236 = p == 95;
  D.23237 = p == 45;
  D.23238 = D.23236 | D.23237;
  if (D.23238 != 0) goto <D.23230>; else goto <D.23231>;
  <D.23230>:
  D.23223 = 1;
  return D.23223;
  <D.23231>:
  D.23223 = 0;
  return D.23223;
}


get_string ()
{
  char * input.19;
  char * input.20;
  char D.23242;
  int D.23243;
  int D.23244;
  char * value.21;
  long int input.22;
  long int start.23;
  long int D.23250;
  long int D.23251;
  long unsigned int D.23252;
  void * value.24;
  long unsigned int D.23254;
  sizetype D.23255;
  char * D.23256;
  char * start;

  start = input;
  goto <D.22540>;
  <D.22539>:
  input.19 = input;
  input.20 = input.19 + 1;
  input = input.20;
  <D.22540>:
  input.19 = input;
  D.23242 = *input.19;
  D.23243 = (int) D.23242;
  D.23244 = is_filenamechar (D.23243);
  if (D.23244 != 0) goto <D.22539>; else goto <D.22541>;
  <D.22541>:
  value.21 = value;
  if (value.21 != 0B) goto <D.23246>; else goto <D.23247>;
  <D.23246>:
  value.21 = value;
  monoeg_g_free (value.21);
  <D.23247>:
  input.19 = input;
  input.22 = (long int) input.19;
  start.23 = (long int) start;
  D.23250 = input.22 - start.23;
  D.23251 = D.23250 + 1;
  D.23252 = (long unsigned int) D.23251;
  value.24 = monoeg_malloc (D.23252);
  value = value.24;
  input.19 = input;
  input.22 = (long int) input.19;
  start.23 = (long int) start;
  D.23250 = input.22 - start.23;
  D.23254 = (long unsigned int) D.23250;
  value.21 = value;
  strncpy (value.21, start, D.23254);
  value.21 = value;
  input.19 = input;
  input.22 = (long int) input.19;
  start.23 = (long int) start;
  D.23250 = input.22 - start.23;
  D.23255 = (sizetype) D.23250;
  D.23256 = value.21 + D.23255;
  *D.23256 = 0;
}


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

  D.23258 = __builtin_object_size (__dest, 1);
  D.23257 = __builtin___strncpy_chk (__dest, __src, __len, D.23258);
  return D.23257;
}


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

  if (str != 0B) goto <D.23260>; else goto <D.23261>;
  <D.23260>:
  D.23262 = __strdup (str);
  return D.23262;
  <D.23261>:
  D.23262 = 0B;
  return D.23262;
}


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

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


cleanup ()
{
  char * value.25;

  value.25 = value;
  if (value.25 != 0B) goto <D.23267>; else goto <D.23268>;
  <D.23267>:
  value.25 = value;
  monoeg_g_free (value.25);
  <D.23268>:
}


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


mono_trace_enter_method (struct MonoMethod * method, char * ebp)
{
  int D.23269;
  void * D.23274;
  void * D.23275;
  short unsigned int D.23276;
  int D.23277;
  int D.23278;
  long unsigned int D.23279;
  long unsigned int D.23280;
  unsigned char D.23281;
  unsigned char D.23282;
  void * D.23285;
  void * D.23286;
  struct MonoDomain * D.23287;
  gboolean * D.23294;
  gboolean * D.23296;
  struct MonoMethodSignature * D.23297;
  struct MonoType * D.23298;
  int D.23299;
  struct MonoMethodSignature * D.23302;
  struct MonoType * D.23303;
  unsigned char D.23304;
  unsigned char D.23305;
  _Bool D.23306;
  long int D.23307;
  long int D.23308;
  void * * D.23311;
  void * D.23312;
  struct MonoMethodSignature * D.23313;
  unsigned char D.23314;
  unsigned char D.23315;
  short unsigned int D.23318;
  sizetype D.23319;
  struct MonoClass * D.23320;
  unsigned char D.23321;
  unsigned char D.23322;
  void * * D.23325;
  struct MonoVTable * D.23329;
  struct MonoClass * D.23330;
  struct MonoDomain * D.23334;
  char * D.23335;
  const char * D.23336;
  const char * D.23337;
  sizetype D.23339;
  sizetype D.23340;
  sizetype D.23341;
  struct MonoJitArgumentInfo * D.23342;
  short unsigned int D.23343;
  sizetype D.23344;
  short unsigned int D.23345;
  struct MonoMethodSignature * D.23346;
  unsigned char D.23347;
  unsigned char D.23348;
  void * * D.23351;
  struct MonoType * D.23353;
  unsigned char D.23354;
  int D.23355;
  signed char D.23356;
  int D.23357;
  short int D.23358;
  int D.23359;
  int D.23360;
  struct MonoVTable * D.23363;
  struct MonoClass * D.23364;
  _Bool D.23365;
  long int D.23366;
  long int D.23367;
  struct MonoClass * D.23376;
  gint32 * D.23379;
  int D.23380;
  struct MonoClass * D.23382;
  struct MonoType * D.23385;
  char * D.23386;
  void * D.23389;
  long int D.23390;
  float D.23391;
  double D.23392;
  double D.23393;
  sizetype D.23394;
  guint8 * D.23395;
  unsigned char D.23396;
  int D.23397;
  struct MonoMethodSignature * D.23398;
  short unsigned int D.23399;
  int D.23400;
  struct _IO_FILE * stdout.26;
  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.23269 = trace_spec.enabled;
  if (D.23269 == 0) goto <D.23270>; else goto <D.23271>;
  <D.23270>:
  return;
  <D.23271>:
  fname = mono_method_full_name (method, 1);
  indent (1);
  printf ("ENTER: %s(", fname);
  monoeg_g_free (fname);
  if (ebp == 0B) goto <D.23272>; else goto <D.23273>;
  <D.23272>:
  D.23274 = __builtin_return_address (1);
  D.23275 = __builtin_extract_return_addr (D.23274);
  printf (") ip: %p\n", D.23275);
  return;
  <D.23273>:
  sig = mono_method_signature (method);
  D.23276 = sig->param_count;
  D.23277 = (int) D.23276;
  D.23278 = D.23277 + 1;
  D.23279 = (long unsigned int) D.23278;
  D.23280 = D.23279 * 6;
  arg_info = __builtin_alloca (D.23280);
  D.23281 = BIT_FIELD_REF <*method, 8, 264>;
  D.23282 = D.23281 & 16;
  if (D.23282 != 0) goto <D.23283>; else goto <D.23284>;
  <D.23283>:
  {
    struct MonoJitInfo * ji;

    D.23285 = __builtin_return_address (0);
    D.23286 = __builtin_extract_return_addr (D.23285);
    D.23287 = mono_domain_get ();
    ji = mini_jit_info_table_find (D.23287, D.23286, 0B);
    if (ji != 0B) goto <D.23288>; else goto <D.23289>;
    <D.23288>:
    gsctx = mono_jit_info_get_generic_sharing_context (ji);
    if (gsctx != 0B) goto <D.23292>; else goto <D.23293>;
    <D.23292>:
    D.23294 = gsctx->var_is_vt;
    if (D.23294 != 0B) goto <D.23290>; else goto <D.23295>;
    <D.23295>:
    D.23296 = gsctx->mvar_is_vt;
    if (D.23296 != 0B) goto <D.23290>; else goto <D.23291>;
    <D.23290>:
    printf (") <gsharedvt>\n");
    return;
    <D.23291>:
    <D.23293>:
    <D.23289>:
  }
  <D.23284>:
  D.23276 = sig->param_count;
  D.23277 = (int) D.23276;
  mono_arch_get_argument_info (gsctx, sig, D.23277, arg_info);
  D.23297 = mono_method_signature (method);
  D.23298 = D.23297->ret;
  D.23299 = mono_type_is_struct (D.23298);
  if (D.23299 != 0) goto <D.23300>; else goto <D.23301>;
  <D.23300>:
  D.23302 = mono_method_signature (method);
  D.23303 = D.23302->ret;
  D.23304 = BIT_FIELD_REF <*D.23303, 8, 88>;
  D.23305 = D.23304 & 64;
  D.23306 = D.23305 != 0;
  D.23307 = (long int) D.23306;
  D.23308 = __builtin_expect (D.23307, 0);
  if (D.23308 != 0) goto <D.23309>; else goto <D.23310>;
  <D.23309>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "trace.c", 430, "!mono_method_signature (method)->ret->byref");
  <D.23310>:
  D.23311 = ebp + 8;
  D.23312 = *D.23311;
  printf ("VALUERET:%p, ", D.23312);
  <D.23301>:
  D.23313 = mono_method_signature (method);
  D.23314 = BIT_FIELD_REF <*D.23313, 8, 112>;
  D.23315 = D.23314 & 64;
  if (D.23315 != 0) goto <D.23316>; else goto <D.23317>;
  <D.23316>:
  {
    void * * this;

    D.23318 = arg_info->offset;
    D.23319 = (sizetype) D.23318;
    this = ebp + D.23319;
    D.23320 = method->klass;
    D.23321 = BIT_FIELD_REF <*D.23320, 8, 256>;
    D.23322 = D.23321 & 8;
    if (D.23322 != 0) goto <D.23323>; else goto <D.23324>;
    <D.23323>:
    D.23325 = MEM[(void * * *)this];
    printf ("value:%p, ", D.23325);
    goto <D.23326>;
    <D.23324>:
    o = MEM[(struct MonoObject * *)this];
    if (o != 0B) goto <D.23327>; else goto <D.23328>;
    <D.23327>:
    D.23329 = o->vtable;
    class = D.23329->klass;
    D.23330 = mono_defaults.string_class;
    if (D.23330 == class) goto <D.23331>; else goto <D.23332>;
    <D.23331>:
    {
      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.23333>;
    <D.23332>:
    D.23329 = o->vtable;
    D.23334 = D.23329->domain;
    D.23335 = D.23334->friendly_name;
    D.23336 = class->name;
    D.23337 = class->name_space;
    printf ("this:%p[%s.%s %s], ", o, D.23337, D.23336, D.23335);
    <D.23333>:
    goto <D.23338>;
    <D.23328>:
    printf ("this:NULL, ");
    <D.23338>:
    <D.23326>:
  }
  <D.23317>:
  i = 0;
  goto <D.22687>;
  <D.22686>:
  {
    void * * cpos;
    int size;
    struct MonoType * type;

    D.23339 = (sizetype) i;
    D.23340 = D.23339 + 1;
    D.23341 = D.23340 * 6;
    D.23342 = arg_info + D.23341;
    D.23343 = D.23342->offset;
    D.23344 = (sizetype) D.23343;
    cpos = ebp + D.23344;
    D.23339 = (sizetype) i;
    D.23340 = D.23339 + 1;
    D.23341 = D.23340 * 6;
    D.23342 = arg_info + D.23341;
    D.23345 = D.23342->size;
    size = (int) D.23345;
    D.23346 = mono_method_signature (method);
    type = D.23346->params[i];
    D.23347 = BIT_FIELD_REF <*type, 8, 88>;
    D.23348 = D.23347 & 64;
    if (D.23348 != 0) goto <D.23349>; else goto <D.23350>;
    <D.23349>:
    D.23351 = MEM[(void * * *)cpos];
    printf ("[BYREF:%p], ", D.23351);
    goto <D.23352>;
    <D.23350>:
    D.23353 = mono_type_get_underlying_type (type);
    D.23354 = D.23353->type;
    D.23355 = (int) D.23354;
    switch (D.23355) <default: <D.22685>, case 2: <D.22659>, case 3: <D.22660>, case 4: <D.22661>, case 5: <D.22662>, case 6: <D.22663>, case 7: <D.22664>, case 8: <D.22665>, case 9: <D.22666>, case 10: <D.22677>, case 11: <D.22678>, case 12: <D.22679>, case 13: <D.22680>, case 14: <D.22667>, case 15: <D.22673>, case 17: <D.22681>, case 18: <D.22670>, case 20: <D.22675>, case 24: <D.22656>, case 25: <D.22657>, case 27: <D.22674>, case 28: <D.22671>, case 29: <D.22676>>
    <D.22656>:
    <D.22657>:
    D.23351 = MEM[(void * * *)cpos];
    printf ("%p, ", D.23351);
    goto <D.22658>;
    <D.22659>:
    <D.22660>:
    <D.22661>:
    <D.22662>:
    D.23356 = MEM[(gint8 *)cpos];
    D.23357 = (int) D.23356;
    printf ("%d, ", D.23357);
    goto <D.22658>;
    <D.22663>:
    <D.22664>:
    D.23358 = MEM[(gint16 *)cpos];
    D.23359 = (int) D.23358;
    printf ("%d, ", D.23359);
    goto <D.22658>;
    <D.22665>:
    <D.22666>:
    D.23360 = MEM[(int *)cpos];
    printf ("%d, ", D.23360);
    goto <D.22658>;
    <D.22667>:
    {
      struct MonoString * s;

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

        D.23363 = MEM[(struct MonoObject *)s].vtable;
        D.23364 = D.23363->klass;
        D.23330 = mono_defaults.string_class;
        D.23365 = D.23364 != D.23330;
        D.23366 = (long int) D.23365;
        D.23367 = __builtin_expect (D.23366, 0);
        if (D.23367 != 0) goto <D.23368>; else goto <D.23369>;
        <D.23368>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "trace.c", 492, "((MonoObject *)s)->vtable->klass == mono_defaults.string_class");
        <D.23369>:
        as = string_to_utf8 (s);
        printf ("[STRING:%p:%s], ", s, as);
        monoeg_g_free (as);
      }
      goto <D.23370>;
      <D.23362>:
      printf ("[STRING:null], ");
      <D.23370>:
      goto <D.22658>;
    }
    <D.22670>:
    <D.22671>:
    o = MEM[(struct MonoObject * *)cpos];
    if (o != 0B) goto <D.23371>; else goto <D.23372>;
    <D.23371>:
    D.23329 = o->vtable;
    class = D.23329->klass;
    D.23330 = mono_defaults.string_class;
    if (D.23330 == class) goto <D.23373>; else goto <D.23374>;
    <D.23373>:
    {
      char * as;

      as = string_to_utf8 (o);
      printf ("[STRING:%p:%s], ", o, as);
      monoeg_g_free (as);
    }
    goto <D.23375>;
    <D.23374>:
    D.23376 = mono_defaults.int32_class;
    if (D.23376 == class) goto <D.23377>; else goto <D.23378>;
    <D.23377>:
    D.23379 = o + 16;
    D.23380 = *D.23379;
    printf ("[INT32:%p:%d], ", o, D.23380);
    goto <D.23381>;
    <D.23378>:
    D.23382 = mono_defaults.monotype_class;
    if (D.23382 == class) goto <D.23383>; else goto <D.23384>;
    <D.23383>:
    D.23385 = MEM[(struct MonoReflectionType *)o].type;
    D.23386 = mono_type_full_name (D.23385);
    printf ("[TYPE:%s], ", D.23386);
    goto <D.23387>;
    <D.23384>:
    D.23336 = class->name;
    D.23337 = class->name_space;
    printf ("[%s.%s:%p], ", D.23337, D.23336, o);
    <D.23387>:
    <D.23381>:
    <D.23375>:
    goto <D.23388>;
    <D.23372>:
    D.23389 = *cpos;
    printf ("%p, ", D.23389);
    <D.23388>:
    goto <D.22658>;
    <D.22673>:
    <D.22674>:
    <D.22675>:
    <D.22676>:
    D.23389 = *cpos;
    printf ("%p, ", D.23389);
    goto <D.22658>;
    <D.22677>:
    <D.22678>:
    D.23390 = MEM[(gint64 *)cpos];
    printf ("0x%016llx, ", D.23390);
    goto <D.22658>;
    <D.22679>:
    D.23391 = MEM[(float *)cpos];
    D.23392 = (double) D.23391;
    printf ("%f, ", D.23392);
    goto <D.22658>;
    <D.22680>:
    D.23393 = MEM[(double *)cpos];
    printf ("%f, ", D.23393);
    goto <D.22658>;
    <D.22681>:
    printf ("[");
    j = 0;
    goto <D.22683>;
    <D.22682>:
    D.23394 = (sizetype) j;
    D.23395 = cpos + D.23394;
    D.23396 = *D.23395;
    D.23397 = (int) D.23396;
    printf ("%02x,", D.23397);
    j = j + 1;
    <D.22683>:
    if (j < size) goto <D.22682>; else goto <D.22684>;
    <D.22684>:
    printf ("], ");
    goto <D.22658>;
    <D.22685>:
    printf ("XX, ");
    <D.22658>:
    <D.23352>:
  }
  i = i + 1;
  <D.22687>:
  D.23398 = mono_method_signature (method);
  D.23399 = D.23398->param_count;
  D.23400 = (int) D.23399;
  if (D.23400 > i) goto <D.22686>; else goto <D.22688>;
  <D.22688>:
  printf (")\n");
  stdout.26 = stdout;
  fflush (stdout.26);
}


indent (int diff)
{
  int indent_level.27;
  int indent_level.28;
  long unsigned int start_time.29;
  long int D.23410;
  long unsigned int start_time.30;
  double D.23412;
  long unsigned int D.23413;
  void * D.23414;

  if (diff < 0) goto <D.23403>; else goto <D.23404>;
  <D.23403>:
  indent_level.27 = indent_level;
  indent_level.28 = indent_level.27 + diff;
  indent_level = indent_level.28;
  <D.23404>:
  start_time.29 = start_time;
  if (start_time.29 == 0) goto <D.23408>; else goto <D.23409>;
  <D.23408>:
  D.23410 = mono_100ns_ticks ();
  start_time.30 = (long unsigned int) D.23410;
  start_time = start_time.30;
  <D.23409>:
  indent_level.27 = indent_level;
  D.23412 = seconds_since_start ();
  D.23413 = GetCurrentThreadId ();
  D.23414 = (void *) D.23413;
  printf ("[%p: %.5f %d] ", D.23414, D.23412, indent_level.27);
  if (diff > 0) goto <D.23415>; else goto <D.23416>;
  <D.23415>:
  indent_level.27 = indent_level;
  indent_level.28 = indent_level.27 + diff;
  indent_level = indent_level.28;
  <D.23416>:
}


seconds_since_start ()
{
  long int D.23417;
  long unsigned int D.23418;
  long unsigned int start_time.31;
  double D.23420;
  double D.23421;
  guint64 diff;

  D.23417 = mono_100ns_ticks ();
  D.23418 = (long unsigned int) D.23417;
  start_time.31 = start_time;
  diff = D.23418 - start_time.31;
  D.23421 = (double) diff;
  D.23420 = D.23421 / 1.0e+7;
  return D.23420;
}


string_to_utf8 (struct MonoString * s)
{
  _Bool D.23423;
  long int D.23424;
  long int D.23425;
  int D.23428;
  char * D.23431;
  long int D.23432;
  mono_unichar2 * D.23433;
  struct GError * error.32;
  char * as;
  struct GError * error;

  try
    {
      error = 0B;
      D.23423 = s == 0B;
      D.23424 = (long int) D.23423;
      D.23425 = __builtin_expect (D.23424, 0);
      if (D.23425 != 0) goto <D.23426>; else goto <D.23427>;
      <D.23426>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "trace.c", 355, "s");
      <D.23427>:
      D.23428 = s->length;
      if (D.23428 == 0) goto <D.23429>; else goto <D.23430>;
      <D.23429>:
      D.23431 = monoeg_strdup ("");
      return D.23431;
      <D.23430>:
      D.23428 = s->length;
      D.23432 = (long int) D.23428;
      D.23433 = mono_string_chars (s);
      as = monoeg_g_utf16_to_utf8 (D.23433, D.23432, 0B, 0B, &error);
      error.32 = error;
      if (error.32 != 0B) goto <D.23435>; else goto <D.23436>;
      <D.23435>:
      error.32 = error;
      monoeg_g_error_free (error.32);
      D.23431 = monoeg_strdup ("<INVALID UTF8>");
      return D.23431;
      <D.23436>:
      D.23431 = as;
      return D.23431;
    }
  finally
    {
      error = {CLOBBER};
    }
}


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

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


mono_trace_leave_method (struct MonoMethod * method)
{
  int D.23441;
  unsigned char D.23444;
  unsigned char D.23445;
  void * D.23448;
  void * D.23449;
  struct MonoDomain * D.23450;
  gboolean * D.23457;
  gboolean * D.23459;
  struct MonoMethodSignature * D.23460;
  unsigned char D.23461;
  int D.23462;
  void * addr.33;
  unsigned int D.23466;
  void * D.23468;
  sizetype D.23469;
  unsigned int D.23470;
  void * D.23471;
  void * D.23472;
  void * addr.34;
  unsigned int D.23479;
  sizetype D.23481;
  unsigned int D.23482;
  void * addr.35;
  unsigned int D.23486;
  sizetype D.23488;
  unsigned int D.23489;
  struct MonoVTable * D.23492;
  struct MonoClass * D.23493;
  struct MonoClass * D.23494;
  _Bool D.23495;
  long int D.23496;
  long int D.23497;
  void * addr.36;
  unsigned int D.23504;
  sizetype D.23506;
  unsigned int D.23507;
  struct MonoVTable * D.23510;
  struct MonoClass * D.23511;
  struct MonoClass * D.23512;
  guint8 * D.23515;
  unsigned char D.23516;
  int D.23517;
  struct MonoClass * D.23519;
  gint32 * D.23522;
  int D.23523;
  struct MonoClass * D.23525;
  gint64 * D.23528;
  long int D.23529;
  const char * D.23531;
  const char * D.23532;
  void * addr.37;
  unsigned int D.23537;
  sizetype D.23539;
  unsigned int D.23540;
  void * addr.38;
  unsigned int D.23544;
  sizetype D.23546;
  unsigned int D.23547;
  void * addr.39;
  unsigned int D.23551;
  sizetype D.23553;
  unsigned int D.23554;
  void * addr.40;
  unsigned int D.23558;
  sizetype D.23560;
  unsigned int D.23561;
  struct MonoClass * D.23562;
  unsigned char D.23563;
  unsigned char D.23564;
  void * addr.41;
  unsigned int D.23570;
  sizetype D.23572;
  unsigned int D.23573;
  sizetype D.23574;
  guint8 * D.23575;
  unsigned char D.23576;
  int D.23577;
  _Bool D.23578;
  _Bool D.23579;
  _Bool D.23580;
  struct MonoMethodSignature * D.23581;
  struct MonoType * D.23582;
  unsigned char D.23583;
  int D.23584;
  struct _IO_FILE * stdout.42;
  struct MonoType * type;
  char * fname;
  struct  ap[1];
  struct MonoGenericSharingContext * gsctx;
  void handle_enum = <<< error >>>;

  try
    {
      D.23441 = trace_spec.enabled;
      if (D.23441 == 0) goto <D.23442>; else goto <D.23443>;
      <D.23442>:
      return;
      <D.23443>:
      __builtin_va_start (&ap, 0);
      fname = mono_method_full_name (method, 1);
      indent (-1);
      printf ("LEAVE: %s", fname);
      monoeg_g_free (fname);
      D.23444 = BIT_FIELD_REF <*method, 8, 264>;
      D.23445 = D.23444 & 16;
      if (D.23445 != 0) goto <D.23446>; else goto <D.23447>;
      <D.23446>:
      {
        struct MonoJitInfo * ji;

        D.23448 = __builtin_return_address (0);
        D.23449 = __builtin_extract_return_addr (D.23448);
        D.23450 = mono_domain_get ();
        ji = mini_jit_info_table_find (D.23450, D.23449, 0B);
        if (ji != 0B) goto <D.23451>; else goto <D.23452>;
        <D.23451>:
        gsctx = mono_jit_info_get_generic_sharing_context (ji);
        if (gsctx != 0B) goto <D.23455>; else goto <D.23456>;
        <D.23455>:
        D.23457 = gsctx->var_is_vt;
        if (D.23457 != 0B) goto <D.23453>; else goto <D.23458>;
        <D.23458>:
        D.23459 = gsctx->mvar_is_vt;
        if (D.23459 != 0B) goto <D.23453>; else goto <D.23454>;
        <D.23453>:
        printf (") <gsharedvt>\n");
        return;
        <D.23454>:
        <D.23456>:
        <D.23452>:
      }
      <D.23447>:
      D.23460 = mono_method_signature (method);
      type = D.23460->ret;
      handle_enum:
      D.23461 = type->type;
      D.23462 = (int) D.23461;
      switch (D.23462) <default: <D.22738>, case 1: <D.22698>, case 2: <D.22700>, case 3: <D.22702>, case 4: <D.22703>, case 5: <D.22704>, case 6: <D.22705>, case 7: <D.22706>, case 8: <D.22707>, case 9: <D.22708>, case 10: <D.22723>, case 11: <D.22725>, case 12: <D.22727>, case 13: <D.22728>, case 14: <D.22712>, case 15: <D.22718>, case 17: <D.22730>, case 18: <D.22715>, case 20: <D.22720>, case 24: <D.22709>, case 25: <D.22710>, case 27: <D.22719>, case 28: <D.22716>, case 29: <D.22721>>
      <D.22698>:
      goto <D.22699>;
      <D.22700>:
      {
        int eax;

        D.23466 = ap.gp_offset;
        if (D.23466 >= 48) goto <D.23464>; else goto <D.23467>;
        <D.23467>:
        D.23468 = ap.reg_save_area;
        D.23466 = ap.gp_offset;
        D.23469 = (sizetype) D.23466;
        addr.33 = D.23468 + D.23469;
        D.23466 = ap.gp_offset;
        D.23470 = D.23466 + 8;
        ap.gp_offset = D.23470;
        goto <D.23465>;
        <D.23464>:
        D.23471 = ap.overflow_arg_area;
        addr.33 = D.23471;
        D.23472 = D.23471 + 8;
        ap.overflow_arg_area = D.23472;
        <D.23465>:
        eax = MEM[(int * {ref-all})addr.33];
        if (eax != 0) goto <D.23473>; else goto <D.23474>;
        <D.23473>:
        printf ("TRUE:%d", eax);
        goto <D.23475>;
        <D.23474>:
        printf ("FALSE");
        <D.23475>:
        goto <D.22699>;
      }
      <D.22702>:
      <D.22703>:
      <D.22704>:
      <D.22705>:
      <D.22706>:
      <D.22707>:
      <D.22708>:
      <D.22709>:
      <D.22710>:
      {
        int eax;

        D.23479 = ap.gp_offset;
        if (D.23479 >= 48) goto <D.23477>; else goto <D.23480>;
        <D.23480>:
        D.23468 = ap.reg_save_area;
        D.23479 = ap.gp_offset;
        D.23481 = (sizetype) D.23479;
        addr.34 = D.23468 + D.23481;
        D.23479 = ap.gp_offset;
        D.23482 = D.23479 + 8;
        ap.gp_offset = D.23482;
        goto <D.23478>;
        <D.23477>:
        D.23471 = ap.overflow_arg_area;
        addr.34 = D.23471;
        D.23472 = D.23471 + 8;
        ap.overflow_arg_area = D.23472;
        <D.23478>:
        eax = MEM[(int * {ref-all})addr.34];
        printf ("result=%d", eax);
        goto <D.22699>;
      }
      <D.22712>:
      {
        struct MonoString * s;

        D.23486 = ap.gp_offset;
        if (D.23486 >= 48) goto <D.23484>; else goto <D.23487>;
        <D.23487>:
        D.23468 = ap.reg_save_area;
        D.23486 = ap.gp_offset;
        D.23488 = (sizetype) D.23486;
        addr.35 = D.23468 + D.23488;
        D.23486 = ap.gp_offset;
        D.23489 = D.23486 + 8;
        ap.gp_offset = D.23489;
        goto <D.23485>;
        <D.23484>:
        D.23471 = ap.overflow_arg_area;
        addr.35 = D.23471;
        D.23472 = D.23471 + 8;
        ap.overflow_arg_area = D.23472;
        <D.23485>:
        s = MEM[(struct MonoString * * {ref-all})addr.35];
        if (s != 0B) goto <D.23490>; else goto <D.23491>;
        <D.23490>:
        {
          char * as;

          D.23492 = MEM[(struct MonoObject *)s].vtable;
          D.23493 = D.23492->klass;
          D.23494 = mono_defaults.string_class;
          D.23495 = D.23493 != D.23494;
          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", 619, "((MonoObject *)s)->vtable->klass == mono_defaults.string_class");
          <D.23499>:
          as = string_to_utf8 (s);
          printf ("[STRING:%p:%s]", s, as);
          monoeg_g_free (as);
        }
        goto <D.23500>;
        <D.23491>:
        printf ("[STRING:null], ");
        <D.23500>:
        goto <D.22699>;
      }
      <D.22715>:
      <D.22716>:
      {
        struct MonoObject * o;

        D.23504 = ap.gp_offset;
        if (D.23504 >= 48) goto <D.23502>; else goto <D.23505>;
        <D.23505>:
        D.23468 = ap.reg_save_area;
        D.23504 = ap.gp_offset;
        D.23506 = (sizetype) D.23504;
        addr.36 = D.23468 + D.23506;
        D.23504 = ap.gp_offset;
        D.23507 = D.23504 + 8;
        ap.gp_offset = D.23507;
        goto <D.23503>;
        <D.23502>:
        D.23471 = ap.overflow_arg_area;
        addr.36 = D.23471;
        D.23472 = D.23471 + 8;
        ap.overflow_arg_area = D.23472;
        <D.23503>:
        o = MEM[(struct MonoObject * * {ref-all})addr.36];
        if (o != 0B) goto <D.23508>; else goto <D.23509>;
        <D.23508>:
        D.23510 = o->vtable;
        D.23511 = D.23510->klass;
        D.23512 = mono_defaults.boolean_class;
        if (D.23511 == D.23512) goto <D.23513>; else goto <D.23514>;
        <D.23513>:
        D.23515 = o + 16;
        D.23516 = *D.23515;
        D.23517 = (int) D.23516;
        printf ("[BOOLEAN:%p:%d]", o, D.23517);
        goto <D.23518>;
        <D.23514>:
        D.23510 = o->vtable;
        D.23511 = D.23510->klass;
        D.23519 = mono_defaults.int32_class;
        if (D.23511 == D.23519) goto <D.23520>; else goto <D.23521>;
        <D.23520>:
        D.23522 = o + 16;
        D.23523 = *D.23522;
        printf ("[INT32:%p:%d]", o, D.23523);
        goto <D.23524>;
        <D.23521>:
        D.23510 = o->vtable;
        D.23511 = D.23510->klass;
        D.23525 = mono_defaults.int64_class;
        if (D.23511 == D.23525) goto <D.23526>; else goto <D.23527>;
        <D.23526>:
        D.23528 = o + 16;
        D.23529 = *D.23528;
        printf ("[INT64:%p:%lld]", o, D.23529);
        goto <D.23530>;
        <D.23527>:
        D.23510 = o->vtable;
        D.23511 = D.23510->klass;
        D.23531 = D.23511->name;
        D.23510 = o->vtable;
        D.23511 = D.23510->klass;
        D.23532 = D.23511->name_space;
        printf ("[%s.%s:%p]", D.23532, D.23531, o);
        <D.23530>:
        <D.23524>:
        <D.23518>:
        goto <D.23533>;
        <D.23509>:
        printf ("[OBJECT:%p]", o);
        <D.23533>:
        goto <D.22699>;
      }
      <D.22718>:
      <D.22719>:
      <D.22720>:
      <D.22721>:
      {
        void * p;

        D.23537 = ap.gp_offset;
        if (D.23537 >= 48) goto <D.23535>; else goto <D.23538>;
        <D.23538>:
        D.23468 = ap.reg_save_area;
        D.23537 = ap.gp_offset;
        D.23539 = (sizetype) D.23537;
        addr.37 = D.23468 + D.23539;
        D.23537 = ap.gp_offset;
        D.23540 = D.23537 + 8;
        ap.gp_offset = D.23540;
        goto <D.23536>;
        <D.23535>:
        D.23471 = ap.overflow_arg_area;
        addr.37 = D.23471;
        D.23472 = D.23471 + 8;
        ap.overflow_arg_area = D.23472;
        <D.23536>:
        p = MEM[(void * * {ref-all})addr.37];
        printf ("result=%p", p);
        goto <D.22699>;
      }
      <D.22723>:
      {
        gint64 l;

        D.23544 = ap.gp_offset;
        if (D.23544 >= 48) goto <D.23542>; else goto <D.23545>;
        <D.23545>:
        D.23468 = ap.reg_save_area;
        D.23544 = ap.gp_offset;
        D.23546 = (sizetype) D.23544;
        addr.38 = D.23468 + D.23546;
        D.23544 = ap.gp_offset;
        D.23547 = D.23544 + 8;
        ap.gp_offset = D.23547;
        goto <D.23543>;
        <D.23542>:
        D.23471 = ap.overflow_arg_area;
        addr.38 = D.23471;
        D.23472 = D.23471 + 8;
        ap.overflow_arg_area = D.23472;
        <D.23543>:
        l = MEM[(gint64 * {ref-all})addr.38];
        printf ("lresult=0x%16llx", l);
        goto <D.22699>;
      }
      <D.22725>:
      {
        gint64 l;

        D.23551 = ap.gp_offset;
        if (D.23551 >= 48) goto <D.23549>; else goto <D.23552>;
        <D.23552>:
        D.23468 = ap.reg_save_area;
        D.23551 = ap.gp_offset;
        D.23553 = (sizetype) D.23551;
        addr.39 = D.23468 + D.23553;
        D.23551 = ap.gp_offset;
        D.23554 = D.23551 + 8;
        ap.gp_offset = D.23554;
        goto <D.23550>;
        <D.23549>:
        D.23471 = ap.overflow_arg_area;
        addr.39 = D.23471;
        D.23472 = D.23471 + 8;
        ap.overflow_arg_area = D.23472;
        <D.23550>:
        l = MEM[(gint64 * {ref-all})addr.39];
        printf ("lresult=0x%16llx", l);
        goto <D.22699>;
      }
      <D.22727>:
      <D.22728>:
      {
        double f;

        D.23558 = ap.fp_offset;
        if (D.23558 >= 176) goto <D.23556>; else goto <D.23559>;
        <D.23559>:
        D.23468 = ap.reg_save_area;
        D.23558 = ap.fp_offset;
        D.23560 = (sizetype) D.23558;
        addr.40 = D.23468 + D.23560;
        D.23558 = ap.fp_offset;
        D.23561 = D.23558 + 16;
        ap.fp_offset = D.23561;
        goto <D.23557>;
        <D.23556>:
        D.23471 = ap.overflow_arg_area;
        addr.40 = D.23471;
        D.23472 = D.23471 + 8;
        ap.overflow_arg_area = D.23472;
        <D.23557>:
        f = MEM[(double * {ref-all})addr.40];
        printf ("FP=%f", f);
        goto <D.22699>;
      }
      <D.22730>:
      D.23562 = type->data.klass;
      D.23563 = BIT_FIELD_REF <*D.23562, 8, 256>;
      D.23564 = D.23563 & 16;
      if (D.23564 != 0) goto <D.23565>; else goto <D.23566>;
      <D.23565>:
      D.23562 = type->data.klass;
      type = mono_class_enum_basetype (D.23562);
      goto handle_enum;
      <D.23566>:
      {
        guint8 * p;
        int j;
        int size;
        int align;

        try
          {
            D.23570 = ap.gp_offset;
            if (D.23570 >= 48) goto <D.23568>; else goto <D.23571>;
            <D.23571>:
            D.23468 = ap.reg_save_area;
            D.23570 = ap.gp_offset;
            D.23572 = (sizetype) D.23570;
            addr.41 = D.23468 + D.23572;
            D.23570 = ap.gp_offset;
            D.23573 = D.23570 + 8;
            ap.gp_offset = D.23573;
            goto <D.23569>;
            <D.23568>:
            D.23471 = ap.overflow_arg_area;
            addr.41 = D.23471;
            D.23472 = D.23471 + 8;
            ap.overflow_arg_area = D.23472;
            <D.23569>:
            p = MEM[(void * * {ref-all})addr.41];
            size = mono_type_size (type, &align);
            printf ("[");
            j = 0;
            goto <D.22736>;
            <D.22735>:
            D.23574 = (sizetype) j;
            D.23575 = p + D.23574;
            D.23576 = *D.23575;
            D.23577 = (int) D.23576;
            printf ("%02x,", D.23577);
            j = j + 1;
            <D.22736>:
            D.23578 = p != 0B;
            D.23579 = j < size;
            D.23580 = D.23578 & D.23579;
            if (D.23580 != 0) goto <D.22735>; else goto <D.22737>;
            <D.22737>:
            printf ("]");
          }
        finally
          {
            align = {CLOBBER};
          }
      }
      goto <D.22699>;
      <D.22738>:
      D.23581 = mono_method_signature (method);
      D.23582 = D.23581->ret;
      D.23583 = D.23582->type;
      D.23584 = (int) D.23583;
      printf ("(unknown return type %x)", D.23584);
      <D.22699>:
      printf ("\n");
      stdout.42 = stdout;
      fflush (stdout.42);
    }
  finally
    {
      ap = {CLOBBER};
    }
}


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


mono_trace_is_enabled ()
{
  gboolean D.23590;

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