mono_trace_eval_exception (struct MonoClass * klass)
{
  gboolean D.24823;
  struct MonoTraceOperation * D.24824;
  unsigned int i.0;
  unsigned int D.24826;
  <unnamed type> D.24827;
  int D.24507;
  int iftmp.1;
  int D.24503;
  const char[1] * D.24833;
  unsigned char D.24834;
  int D.24835;
  unsigned char D.24836;
  int D.24837;
  _Bool D.24838;
  _Bool D.24839;
  _Bool D.24840;
  const unsigned char * D.24843;
  unsigned char D.24844;
  int D.24845;
  const unsigned char * D.24846;
  unsigned char D.24847;
  int D.24848;
  _Bool D.24849;
  _Bool D.24850;
  const unsigned char * D.24853;
  unsigned char D.24854;
  int D.24855;
  const unsigned char * D.24856;
  unsigned char D.24857;
  int D.24858;
  _Bool D.24859;
  _Bool D.24860;
  const unsigned char * D.24863;
  unsigned char D.24864;
  int D.24865;
  const unsigned char * D.24866;
  unsigned char D.24867;
  int D.24868;
  void * D.24870;
  unsigned char D.24871;
  int D.24872;
  int D.24516;
  int iftmp.2;
  int D.24512;
  const char[4] * D.24877;
  unsigned char D.24878;
  int D.24879;
  unsigned char D.24880;
  int D.24881;
  _Bool D.24882;
  _Bool D.24883;
  _Bool D.24884;
  const unsigned char * D.24887;
  unsigned char D.24888;
  int D.24889;
  const unsigned char * D.24890;
  unsigned char D.24891;
  int D.24892;
  _Bool D.24893;
  _Bool D.24894;
  const unsigned char * D.24897;
  unsigned char D.24898;
  int D.24899;
  const unsigned char * D.24900;
  unsigned char D.24901;
  int D.24902;
  _Bool D.24903;
  _Bool D.24904;
  const unsigned char * D.24907;
  unsigned char D.24908;
  int D.24909;
  const unsigned char * D.24910;
  unsigned char D.24911;
  int D.24912;
  void * D.24914;
  int D.24525;
  int iftmp.3;
  int D.24521;
  unsigned char D.24921;
  int D.24922;
  _Bool D.24923;
  _Bool D.24924;
  _Bool D.24925;
  const unsigned char * D.24928;
  unsigned char D.24929;
  int D.24930;
  _Bool D.24931;
  _Bool D.24932;
  const unsigned char * D.24935;
  unsigned char D.24936;
  int D.24937;
  _Bool D.24938;
  _Bool D.24939;
  const unsigned char * D.24942;
  unsigned char D.24943;
  int D.24944;
  int D.24534;
  const char * D.24947;
  int D.24543;
  const char * D.24948;
  int D.24951;
  int D.24959;
  int include;
  int i;

  include = 0;
  if (klass == 0B) goto <D.24821>; else goto <D.24822>;
  <D.24821>:
  D.24823 = 0;
  return D.24823;
  <D.24822>:
  i = 0;
  goto <D.24547>;
  <D.24546>:
  {
    struct MonoTraceOperation * op;
    int inc;

    D.24824 = trace_spec.ops;
    i.0 = (unsigned int) i;
    D.24826 = i.0 * 16;
    op = D.24824 + D.24826;
    inc = 0;
    D.24827 = op->op;
    switch (D.24827) <default: <D.24545>, case 6: <D.24498>>
    <D.24498>:
    {
      size_t __s1_len;
      size_t __s2_len;

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

        __s2 = op->data;
        D.24833 = "";
        D.24834 = MEM[(const unsigned char *)D.24833];
        D.24835 = (int) D.24834;
        D.24836 = *__s2;
        D.24837 = (int) D.24836;
        __result = D.24835 - D.24837;
        {
          D.24838 = __s1_len != 0;
          D.24839 = __result == 0;
          D.24840 = D.24838 & D.24839;
          if (D.24840 != 0) goto <D.24841>; else goto <D.24842>;
          <D.24841>:
          D.24843 = &MEM[(void *)"" + 1B];
          D.24844 = *D.24843;
          D.24845 = (int) D.24844;
          D.24846 = __s2 + 1;
          D.24847 = *D.24846;
          D.24848 = (int) D.24847;
          __result = D.24845 - D.24848;
          D.24849 = __s1_len > 1;
          D.24839 = __result == 0;
          D.24850 = D.24849 & D.24839;
          if (D.24850 != 0) goto <D.24851>; else goto <D.24852>;
          <D.24851>:
          D.24853 = &MEM[(void *)"" + 2B];
          D.24854 = *D.24853;
          D.24855 = (int) D.24854;
          D.24856 = __s2 + 2;
          D.24857 = *D.24856;
          D.24858 = (int) D.24857;
          __result = D.24855 - D.24858;
          D.24859 = __s1_len > 2;
          D.24839 = __result == 0;
          D.24860 = D.24859 & D.24839;
          if (D.24860 != 0) goto <D.24861>; else goto <D.24862>;
          <D.24861>:
          D.24863 = &MEM[(void *)"" + 3B];
          D.24864 = *D.24863;
          D.24865 = (int) D.24864;
          D.24866 = __s2 + 3;
          D.24867 = *D.24866;
          D.24868 = (int) D.24867;
          __result = D.24865 - D.24868;
          <D.24862>:
          <D.24852>:
          <D.24842>:
        }
        D.24503 = __result;
      }
      iftmp.1 = D.24503;
      goto <D.24869>;
      <D.24832>:
      D.24870 = op->data;
      D.24871 = MEM[(const unsigned char * {ref-all})D.24870];
      D.24872 = (int) D.24871;
      iftmp.1 = -D.24872;
      <D.24869>:
      D.24507 = iftmp.1;
    }
    if (D.24507 == 0) goto <D.24873>; else goto <D.24828>;
    <D.24873>:
    {
      size_t __s1_len;
      size_t __s2_len;

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

        __s2 = op->data2;
        D.24877 = "all";
        D.24878 = MEM[(const unsigned char *)D.24877];
        D.24879 = (int) D.24878;
        D.24880 = *__s2;
        D.24881 = (int) D.24880;
        __result = D.24879 - D.24881;
        {
          D.24882 = __s1_len != 0;
          D.24883 = __result == 0;
          D.24884 = D.24882 & D.24883;
          if (D.24884 != 0) goto <D.24885>; else goto <D.24886>;
          <D.24885>:
          D.24887 = &MEM[(void *)"all" + 1B];
          D.24888 = *D.24887;
          D.24889 = (int) D.24888;
          D.24890 = __s2 + 1;
          D.24891 = *D.24890;
          D.24892 = (int) D.24891;
          __result = D.24889 - D.24892;
          D.24893 = __s1_len > 1;
          D.24883 = __result == 0;
          D.24894 = D.24893 & D.24883;
          if (D.24894 != 0) goto <D.24895>; else goto <D.24896>;
          <D.24895>:
          D.24897 = &MEM[(void *)"all" + 2B];
          D.24898 = *D.24897;
          D.24899 = (int) D.24898;
          D.24900 = __s2 + 2;
          D.24901 = *D.24900;
          D.24902 = (int) D.24901;
          __result = D.24899 - D.24902;
          D.24903 = __s1_len > 2;
          D.24883 = __result == 0;
          D.24904 = D.24903 & D.24883;
          if (D.24904 != 0) goto <D.24905>; else goto <D.24906>;
          <D.24905>:
          D.24907 = &MEM[(void *)"all" + 3B];
          D.24908 = *D.24907;
          D.24909 = (int) D.24908;
          D.24910 = __s2 + 3;
          D.24911 = *D.24910;
          D.24912 = (int) D.24911;
          __result = D.24909 - D.24912;
          <D.24906>:
          <D.24896>:
          <D.24886>:
        }
        D.24512 = __result;
      }
      iftmp.2 = D.24512;
      goto <D.24913>;
      <D.24876>:
      D.24914 = op->data2;
      iftmp.2 = __builtin_strcmp ("all", D.24914);
      <D.24913>:
      D.24516 = iftmp.2;
    }
    if (D.24516 == 0) goto <D.24915>; else goto <D.24828>;
    <D.24915>:
    inc = 1;
    goto <D.24829>;
    <D.24828>:
    {
      size_t __s1_len;
      size_t __s2_len;

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

        __s2 = op->data;
        D.24833 = "";
        D.24834 = MEM[(const unsigned char *)D.24833];
        D.24835 = (int) D.24834;
        D.24921 = *__s2;
        D.24922 = (int) D.24921;
        __result = D.24835 - D.24922;
        {
          D.24923 = __s1_len != 0;
          D.24924 = __result == 0;
          D.24925 = D.24923 & D.24924;
          if (D.24925 != 0) goto <D.24926>; else goto <D.24927>;
          <D.24926>:
          D.24843 = &MEM[(void *)"" + 1B];
          D.24844 = *D.24843;
          D.24845 = (int) D.24844;
          D.24928 = __s2 + 1;
          D.24929 = *D.24928;
          D.24930 = (int) D.24929;
          __result = D.24845 - D.24930;
          D.24931 = __s1_len > 1;
          D.24924 = __result == 0;
          D.24932 = D.24931 & D.24924;
          if (D.24932 != 0) goto <D.24933>; else goto <D.24934>;
          <D.24933>:
          D.24853 = &MEM[(void *)"" + 2B];
          D.24854 = *D.24853;
          D.24855 = (int) D.24854;
          D.24935 = __s2 + 2;
          D.24936 = *D.24935;
          D.24937 = (int) D.24936;
          __result = D.24855 - D.24937;
          D.24938 = __s1_len > 2;
          D.24924 = __result == 0;
          D.24939 = D.24938 & D.24924;
          if (D.24939 != 0) goto <D.24940>; else goto <D.24941>;
          <D.24940>:
          D.24863 = &MEM[(void *)"" + 3B];
          D.24864 = *D.24863;
          D.24865 = (int) D.24864;
          D.24942 = __s2 + 3;
          D.24943 = *D.24942;
          D.24944 = (int) D.24943;
          __result = D.24865 - D.24944;
          <D.24941>:
          <D.24934>:
          <D.24927>:
        }
        D.24521 = __result;
      }
      iftmp.3 = D.24521;
      goto <D.24945>;
      <D.24920>:
      D.24870 = op->data;
      D.24871 = MEM[(const unsigned char * {ref-all})D.24870];
      D.24872 = (int) D.24871;
      iftmp.3 = -D.24872;
      <D.24945>:
      D.24525 = iftmp.3;
    }
    if (D.24525 == 0) goto <D.24916>; else goto <D.24946>;
    <D.24946>:
    {
      size_t __s1_len;
      size_t __s2_len;

      D.24947 = klass->name_space;
      D.24870 = op->data;
      D.24534 = __builtin_strcmp (D.24947, D.24870);
    }
    if (D.24534 == 0) goto <D.24916>; else goto <D.24917>;
    <D.24916>:
    {
      size_t __s1_len;
      size_t __s2_len;

      D.24948 = klass->name;
      D.24914 = op->data2;
      D.24543 = __builtin_strcmp (D.24948, D.24914);
    }
    if (D.24543 == 0) goto <D.24949>; else goto <D.24950>;
    <D.24949>:
    inc = 1;
    <D.24950>:
    <D.24917>:
    <D.24829>:
    goto <D.24544>;
    <D.24545>:
    goto <D.24544>;
    <D.24544>:
    D.24951 = op->exclude;
    if (D.24951 != 0) goto <D.24952>; else goto <D.24953>;
    <D.24952>:
    if (inc != 0) goto <D.24954>; else goto <D.24955>;
    <D.24954>:
    include = 0;
    <D.24955>:
    goto <D.24956>;
    <D.24953>:
    if (inc != 0) goto <D.24957>; else goto <D.24958>;
    <D.24957>:
    include = 1;
    <D.24958>:
    <D.24956>:
  }
  i = i + 1;
  <D.24547>:
  D.24959 = trace_spec.len;
  if (D.24959 > i) goto <D.24546>; else goto <D.24548>;
  <D.24548>:
  D.24823 = include;
  return D.24823;
}


mono_trace_eval (struct MonoMethod * method)
{
  struct MonoTraceOperation * D.24962;
  unsigned int i.4;
  unsigned int D.24964;
  <unnamed type> D.24965;
  struct MonoAssembly * D.24966;
  struct MonoClass * D.24969;
  struct MonoImage * D.24970;
  struct MonoImage * D.24971;
  unsigned char D.24974;
  unsigned char D.24975;
  _Bool D.24976;
  _Bool D.24977;
  _Bool D.24978;
  void * D.24981;
  int D.24982;
  int D.24570;
  const char * D.24985;
  int D.24579;
  const char * D.24988;
  void * D.24989;
  int D.24589;
  const char * D.24992;
  int D.24599;
  int D.24998;
  int D.25006;
  gboolean D.25007;
  int include;
  int i;

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

    D.24962 = trace_spec.ops;
    i.4 = (unsigned int) i;
    D.24964 = i.4 * 16;
    op = D.24962 + D.24964;
    inc = 0;
    D.24965 = op->op;
    switch (D.24965) <default: <D.24997>, case 0: <D.24556>, case 1: <D.24558>, case 2: <D.24560>, case 3: <D.24580>, case 4: <D.24561>, case 5: <D.24590>, case 6: <D.24600>, case 7: <D.24559>>
    <D.24556>:
    inc = 1;
    goto <D.24557>;
    <D.24558>:
    D.24966 = trace_spec.assembly;
    if (D.24966 != 0B) goto <D.24967>; else goto <D.24968>;
    <D.24967>:
    D.24969 = method->klass;
    D.24970 = D.24969->image;
    D.24966 = trace_spec.assembly;
    D.24971 = mono_assembly_get_image (D.24966);
    if (D.24970 == D.24971) goto <D.24972>; else goto <D.24973>;
    <D.24972>:
    inc = 1;
    <D.24973>:
    <D.24968>:
    goto <D.24557>;
    <D.24559>:
    D.24974 = BIT_FIELD_REF <*method, 8, 160>;
    D.24975 = D.24974 & 124;
    D.24976 = D.24975 == 20;
    D.24977 = D.24975 == 24;
    D.24978 = D.24976 | D.24977;
    if (D.24978 != 0) goto <D.24979>; else goto <D.24980>;
    <D.24979>:
    inc = 1;
    <D.24980>:
    goto <D.24557>;
    <D.24560>:
    D.24981 = op->data;
    D.24982 = mono_method_desc_full_match (D.24981, method);
    if (D.24982 != 0) goto <D.24983>; else goto <D.24984>;
    <D.24983>:
    inc = 1;
    <D.24984>:
    goto <D.24557>;
    <D.24561>:
    {
      size_t __s1_len;
      size_t __s2_len;

      D.24969 = method->klass;
      D.24985 = D.24969->name_space;
      D.24981 = op->data;
      D.24570 = __builtin_strcmp (D.24985, D.24981);
    }
    if (D.24570 == 0) goto <D.24986>; else goto <D.24987>;
    <D.24986>:
    {
      size_t __s1_len;
      size_t __s2_len;

      D.24969 = method->klass;
      D.24988 = D.24969->name;
      D.24989 = op->data2;
      D.24579 = __builtin_strcmp (D.24988, D.24989);
    }
    if (D.24579 == 0) goto <D.24990>; else goto <D.24991>;
    <D.24990>:
    inc = 1;
    <D.24991>:
    <D.24987>:
    goto <D.24557>;
    <D.24580>:
    {
      size_t __s1_len;
      size_t __s2_len;

      D.24969 = method->klass;
      D.24970 = D.24969->image;
      D.24992 = mono_image_get_name (D.24970);
      D.24981 = op->data;
      D.24589 = __builtin_strcmp (D.24992, D.24981);
    }
    if (D.24589 == 0) goto <D.24993>; else goto <D.24994>;
    <D.24993>:
    inc = 1;
    <D.24994>:
    goto <D.24557>;
    <D.24590>:
    {
      size_t __s1_len;
      size_t __s2_len;

      D.24969 = method->klass;
      D.24985 = D.24969->name_space;
      D.24981 = op->data;
      D.24599 = __builtin_strcmp (D.24985, D.24981);
    }
    if (D.24599 == 0) goto <D.24995>; else goto <D.24996>;
    <D.24995>:
    inc = 1;
    <D.24996>:
    <D.24600>:
    goto <D.24557>;
    <D.24997>:
    <D.24557>:
    D.24998 = op->exclude;
    if (D.24998 != 0) goto <D.24999>; else goto <D.25000>;
    <D.24999>:
    if (inc != 0) goto <D.25001>; else goto <D.25002>;
    <D.25001>:
    include = 0;
    <D.25002>:
    goto <D.25003>;
    <D.25000>:
    if (inc != 0) goto <D.25004>; else goto <D.25005>;
    <D.25004>:
    include = 1;
    <D.25005>:
    <D.25003>:
  }
  i = i + 1;
  <D.24602>:
  D.25006 = trace_spec.len;
  if (D.25006 > i) goto <D.24601>; else goto <D.24603>;
  <D.24603>:
  D.25007 = include;
  return D.25007;
}


mono_trace_parse_options (const char * options)
{
  char D.25009;
  void * D.25012;
  struct MonoTraceOperation * D.25013;
  struct MonoTraceSpec * D.25014;
  unsigned int size.5;
  unsigned int D.25018;
  void * D.25019;
  int last_used.6;
  char * p;
  int size;
  int last_used;
  int token;

  try
    {
      p = options;
      size = 1;
      trace_spec.enabled = 1;
      D.25009 = *p;
      if (D.25009 == 0) goto <D.25010>; else goto <D.25011>;
      <D.25010>:
      trace_spec.len = 1;
      D.25012 = monoeg_malloc0 (16);
      trace_spec.ops = D.25012;
      D.25013 = trace_spec.ops;
      D.25013->op = 0;
      D.25014 = &trace_spec;
      return D.25014;
      <D.25011>:
      p = options;
      goto <D.24689>;
      <D.24688>:
      D.25009 = *p;
      if (D.25009 == 44) goto <D.25015>; else goto <D.25016>;
      <D.25015>:
      size = size + 1;
      <D.25016>:
      p = p + 1;
      <D.24689>:
      D.25009 = *p;
      if (D.25009 != 0) goto <D.24688>; else goto <D.24690>;
      <D.24690>:
      size.5 = (unsigned int) size;
      D.25018 = size.5 * 16;
      D.25019 = monoeg_malloc0 (D.25018);
      trace_spec.ops = D.25019;
      input = options;
      last_used = 0;
      goto <D.24691>;
      <D.24692>:
      if (token == 12) goto <D.25020>; else goto <D.25021>;
      <D.25020>:
      D.25014 = 0B;
      return D.25014;
      <D.25021>:
      if (token == 10) goto <D.25022>; else goto <D.25023>;
      <D.25022>:
      // predicted unlikely by continue predictor.
      goto <D.24691>;
      <D.25023>:
      <D.24691>:
      token = get_spec (&last_used);
      if (token != 11) goto <D.24692>; else goto <D.24693>;
      <D.24693>:
      last_used.6 = last_used;
      trace_spec.len = last_used.6;
      cleanup ();
      D.25014 = &trace_spec;
      return D.25014;
    }
  finally
    {
      last_used = {CLOBBER};
    }
}


get_spec (int * last)
{
  struct _IO_FILE * stderr.7;
  int D.25032;
  struct MonoTraceOperation * D.25035;
  int D.25036;
  sizetype D.25037;
  sizetype D.25038;
  sizetype D.25039;
  struct MonoTraceOperation * D.25040;
  unsigned int token.8;
  unsigned int D.25042;
  char * value.9;
  unsigned int D.25050;
  unsigned int D.25051;
  struct MonoTraceOperation * D.25052;
  gchar * D.25065;
  _Bool D.25067;
  _Bool D.25068;
  _Bool D.25069;
  char * p.10;
  gchar * D.25075;
  gchar * D.25076;
  gchar * D.25078;
  gchar * D.25079;
  MonoTraceOpcode iftmp.11;
  gchar * D.25087;
  int D.25092;
  int token;

  token = get_token ();
  if (token == 8) goto <D.25027>; else goto <D.25028>;
  <D.25027>:
  token = get_spec (last);
  if (token == 8) goto <D.25029>; else goto <D.25030>;
  <D.25029>:
  stderr.7 = stderr;
  fprintf (stderr.7, "Expecting an expression");
  D.25032 = 12;
  return D.25032;
  <D.25030>:
  if (token == 12) goto <D.25033>; else goto <D.25034>;
  <D.25033>:
  D.25032 = token;
  return D.25032;
  <D.25034>:
  D.25035 = trace_spec.ops;
  D.25036 = *last;
  D.25037 = (sizetype) D.25036;
  D.25038 = D.25037 + 268435455;
  D.25039 = D.25038 * 16;
  D.25040 = D.25035 + D.25039;
  D.25040->exclude = 1;
  D.25032 = 10;
  return D.25032;
  <D.25028>:
  token.8 = (unsigned int) token;
  D.25042 = token.8 + 4294967286;
  if (D.25042 <= 2) goto <D.25043>; else goto <D.25044>;
  <D.25043>:
  D.25032 = token;
  return D.25032;
  <D.25044>:
  if (token == 0) goto <D.25045>; else goto <D.25046>;
  <D.25045>:
  {
    struct MonoMethodDesc * desc;

    value.9 = value;
    desc = mono_method_desc_new (value.9, 1);
    if (desc == 0B) goto <D.25048>; else goto <D.25049>;
    <D.25048>:
    stderr.7 = stderr;
    value.9 = value;
    fprintf (stderr.7, "Invalid method name: %s\n", value.9);
    D.25032 = 12;
    return D.25032;
    <D.25049>:
    D.25035 = trace_spec.ops;
    D.25036 = *last;
    D.25050 = (unsigned int) D.25036;
    D.25051 = D.25050 * 16;
    D.25052 = D.25035 + D.25051;
    D.25052->op = 2;
    D.25035 = trace_spec.ops;
    D.25036 = *last;
    D.25050 = (unsigned int) D.25036;
    D.25051 = D.25050 * 16;
    D.25052 = D.25035 + D.25051;
    D.25052->data = desc;
  }
  goto <D.25053>;
  <D.25046>:
  if (token == 2) goto <D.25054>; else goto <D.25055>;
  <D.25054>:
  D.25035 = trace_spec.ops;
  D.25036 = *last;
  D.25050 = (unsigned int) D.25036;
  D.25051 = D.25050 * 16;
  D.25052 = D.25035 + D.25051;
  D.25052->op = 0;
  goto <D.25056>;
  <D.25055>:
  if (token == 3) goto <D.25057>; else goto <D.25058>;
  <D.25057>:
  D.25035 = trace_spec.ops;
  D.25036 = *last;
  D.25050 = (unsigned int) D.25036;
  D.25051 = D.25050 * 16;
  D.25052 = D.25035 + D.25051;
  D.25052->op = 1;
  goto <D.25059>;
  <D.25058>:
  if (token == 6) goto <D.25060>; else goto <D.25061>;
  <D.25060>:
  D.25035 = trace_spec.ops;
  D.25036 = *last;
  D.25050 = (unsigned int) D.25036;
  D.25051 = D.25050 * 16;
  D.25052 = D.25035 + D.25051;
  D.25052->op = 7;
  goto <D.25062>;
  <D.25061>:
  if (token == 5) goto <D.25063>; else goto <D.25064>;
  <D.25063>:
  D.25035 = trace_spec.ops;
  D.25036 = *last;
  D.25050 = (unsigned int) D.25036;
  D.25051 = D.25050 * 16;
  D.25052 = D.25035 + D.25051;
  D.25052->op = 5;
  D.25035 = trace_spec.ops;
  D.25036 = *last;
  D.25050 = (unsigned int) D.25036;
  D.25051 = D.25050 * 16;
  D.25052 = D.25035 + D.25051;
  value.9 = value;
  D.25065 = monoeg_strdup (value.9);
  D.25052->data = D.25065;
  goto <D.25066>;
  <D.25064>:
  D.25067 = token == 1;
  D.25068 = token == 4;
  D.25069 = D.25067 | D.25068;
  if (D.25069 != 0) goto <D.25070>; else goto <D.25071>;
  <D.25070>:
  {
    char * p;

    value.9 = value;
    p = strrchr (value.9, 46);
    if (p != 0B) goto <D.25072>; else goto <D.25073>;
    <D.25072>:
    p.10 = p;
    p = p.10 + 1;
    *p.10 = 0;
    D.25035 = trace_spec.ops;
    D.25036 = *last;
    D.25050 = (unsigned int) D.25036;
    D.25051 = D.25050 * 16;
    D.25052 = D.25035 + D.25051;
    value.9 = value;
    D.25075 = monoeg_strdup (value.9);
    D.25052->data = D.25075;
    D.25035 = trace_spec.ops;
    D.25036 = *last;
    D.25050 = (unsigned int) D.25036;
    D.25051 = D.25050 * 16;
    D.25052 = D.25035 + D.25051;
    D.25076 = monoeg_strdup (p);
    D.25052->data2 = D.25076;
    goto <D.25077>;
    <D.25073>:
    D.25035 = trace_spec.ops;
    D.25036 = *last;
    D.25050 = (unsigned int) D.25036;
    D.25051 = D.25050 * 16;
    D.25052 = D.25035 + D.25051;
    D.25078 = monoeg_strdup ("");
    D.25052->data = D.25078;
    D.25035 = trace_spec.ops;
    D.25036 = *last;
    D.25050 = (unsigned int) D.25036;
    D.25051 = D.25050 * 16;
    D.25052 = D.25035 + D.25051;
    value.9 = value;
    D.25079 = monoeg_strdup (value.9);
    D.25052->data2 = D.25079;
    <D.25077>:
    D.25035 = trace_spec.ops;
    D.25036 = *last;
    D.25050 = (unsigned int) D.25036;
    D.25051 = D.25050 * 16;
    D.25052 = D.25035 + D.25051;
    if (token == 1) goto <D.25081>; else goto <D.25082>;
    <D.25081>:
    iftmp.11 = 4;
    goto <D.25083>;
    <D.25082>:
    iftmp.11 = 6;
    <D.25083>:
    D.25052->op = iftmp.11;
  }
  goto <D.25084>;
  <D.25071>:
  if (token == 7) goto <D.25085>; else goto <D.25086>;
  <D.25085>:
  D.25035 = trace_spec.ops;
  D.25036 = *last;
  D.25050 = (unsigned int) D.25036;
  D.25051 = D.25050 * 16;
  D.25052 = D.25035 + D.25051;
  D.25052->op = 3;
  D.25035 = trace_spec.ops;
  D.25036 = *last;
  D.25050 = (unsigned int) D.25036;
  D.25051 = D.25050 * 16;
  D.25052 = D.25035 + D.25051;
  value.9 = value;
  D.25087 = monoeg_strdup (value.9);
  D.25052->data = D.25087;
  goto <D.25088>;
  <D.25086>:
  if (token == 9) goto <D.25089>; else goto <D.25090>;
  <D.25089>:
  trace_spec.enabled = 0;
  goto <D.25091>;
  <D.25090>:
  stderr.7 = stderr;
  fprintf (stderr.7, "Syntax error in trace option specification\n");
  D.25032 = 12;
  return D.25032;
  <D.25091>:
  <D.25088>:
  <D.25084>:
  <D.25066>:
  <D.25062>:
  <D.25059>:
  <D.25056>:
  <D.25053>:
  D.25036 = *last;
  D.25092 = D.25036 + 1;
  *last = D.25092;
  D.25032 = 10;
  return D.25032;
}


get_token ()
{
  char * input.12;
  char * input.13;
  char D.25096;
  int D.25099;
  char D.25102;
  char * input.14;
  int D.25120;
  int D.24644;
  int iftmp.15;
  int D.24643;
  const char[4] * D.25126;
  unsigned char D.25127;
  int D.25128;
  unsigned char D.25129;
  int D.25130;
  _Bool D.25131;
  _Bool D.25132;
  _Bool D.25133;
  const unsigned char * D.25136;
  unsigned char D.25137;
  int D.25138;
  const unsigned char * D.25139;
  unsigned char D.25140;
  int D.25141;
  _Bool D.25142;
  _Bool D.25143;
  const unsigned char * D.25146;
  unsigned char D.25147;
  int D.25148;
  const unsigned char * D.25149;
  unsigned char D.25150;
  int D.25151;
  _Bool D.25152;
  _Bool D.25153;
  const unsigned char * D.25156;
  unsigned char D.25157;
  int D.25158;
  const unsigned char * D.25159;
  unsigned char D.25160;
  int D.25161;
  char * value.16;
  int D.24653;
  int iftmp.17;
  int D.24652;
  const char[8] * D.25169;
  unsigned char D.25170;
  int D.25171;
  unsigned char D.25172;
  int D.25173;
  _Bool D.25174;
  _Bool D.25175;
  _Bool D.25176;
  const unsigned char * D.25179;
  unsigned char D.25180;
  int D.25181;
  const unsigned char * D.25182;
  unsigned char D.25183;
  int D.25184;
  _Bool D.25185;
  _Bool D.25186;
  const unsigned char * D.25189;
  unsigned char D.25190;
  int D.25191;
  const unsigned char * D.25192;
  unsigned char D.25193;
  int D.25194;
  _Bool D.25195;
  _Bool D.25196;
  const unsigned char * D.25199;
  unsigned char D.25200;
  int D.25201;
  const unsigned char * D.25202;
  unsigned char D.25203;
  int D.25204;
  int D.24662;
  int iftmp.18;
  int D.24661;
  const char[8] * D.25211;
  unsigned char D.25212;
  int D.25213;
  unsigned char D.25214;
  int D.25215;
  _Bool D.25216;
  _Bool D.25217;
  _Bool D.25218;
  const unsigned char * D.25221;
  unsigned char D.25222;
  int D.25223;
  const unsigned char * D.25224;
  unsigned char D.25225;
  int D.25226;
  _Bool D.25227;
  _Bool D.25228;
  const unsigned char * D.25231;
  unsigned char D.25232;
  int D.25233;
  const unsigned char * D.25234;
  unsigned char D.25235;
  int D.25236;
  _Bool D.25237;
  _Bool D.25238;
  const unsigned char * D.25241;
  unsigned char D.25242;
  int D.25243;
  const unsigned char * D.25244;
  unsigned char D.25245;
  int D.25246;
  int D.24671;
  int iftmp.19;
  int D.24670;
  const char[9] * D.25253;
  unsigned char D.25254;
  int D.25255;
  unsigned char D.25256;
  int D.25257;
  _Bool D.25258;
  _Bool D.25259;
  _Bool D.25260;
  const unsigned char * D.25263;
  unsigned char D.25264;
  int D.25265;
  const unsigned char * D.25266;
  unsigned char D.25267;
  int D.25268;
  _Bool D.25269;
  _Bool D.25270;
  const unsigned char * D.25273;
  unsigned char D.25274;
  int D.25275;
  const unsigned char * D.25276;
  unsigned char D.25277;
  int D.25278;
  _Bool D.25279;
  _Bool D.25280;
  const unsigned char * D.25283;
  unsigned char D.25284;
  int D.25285;
  const unsigned char * D.25286;
  unsigned char D.25287;
  int D.25288;
  struct _IO_FILE * stderr.20;

  goto <D.24634>;
  <D.24633>:
  input.12 = input;
  input.13 = input.12 + 1;
  input = input.13;
  <D.24634>:
  input.12 = input;
  D.25096 = *input.12;
  if (D.25096 == 43) goto <D.24633>; else goto <D.24635>;
  <D.24635>:
  input.12 = input;
  D.25096 = *input.12;
  if (D.25096 == 0) goto <D.25097>; else goto <D.25098>;
  <D.25097>:
  D.25099 = 11;
  return D.25099;
  <D.25098>:
  input.12 = input;
  D.25096 = *input.12;
  if (D.25096 == 77) goto <D.25100>; else goto <D.25101>;
  <D.25100>:
  input.12 = input;
  input.13 = input.12 + 1;
  D.25102 = *input.13;
  if (D.25102 == 58) goto <D.25103>; else goto <D.25104>;
  <D.25103>:
  input.12 = input;
  input.14 = input.12 + 2;
  input = input.14;
  get_string ();
  D.25099 = 0;
  return D.25099;
  <D.25104>:
  <D.25101>:
  input.12 = input;
  D.25096 = *input.12;
  if (D.25096 == 78) goto <D.25106>; else goto <D.25107>;
  <D.25106>:
  input.12 = input;
  input.13 = input.12 + 1;
  D.25102 = *input.13;
  if (D.25102 == 58) goto <D.25108>; else goto <D.25109>;
  <D.25108>:
  input.12 = input;
  input.14 = input.12 + 2;
  input = input.14;
  get_string ();
  D.25099 = 5;
  return D.25099;
  <D.25109>:
  <D.25107>:
  input.12 = input;
  D.25096 = *input.12;
  if (D.25096 == 84) goto <D.25110>; else goto <D.25111>;
  <D.25110>:
  input.12 = input;
  input.13 = input.12 + 1;
  D.25102 = *input.13;
  if (D.25102 == 58) goto <D.25112>; else goto <D.25113>;
  <D.25112>:
  input.12 = input;
  input.14 = input.12 + 2;
  input = input.14;
  get_string ();
  D.25099 = 1;
  return D.25099;
  <D.25113>:
  <D.25111>:
  input.12 = input;
  D.25096 = *input.12;
  if (D.25096 == 69) goto <D.25114>; else goto <D.25115>;
  <D.25114>:
  input.12 = input;
  input.13 = input.12 + 1;
  D.25102 = *input.13;
  if (D.25102 == 58) goto <D.25116>; else goto <D.25117>;
  <D.25116>:
  input.12 = input;
  input.14 = input.12 + 2;
  input = input.14;
  get_string ();
  D.25099 = 4;
  return D.25099;
  <D.25117>:
  <D.25115>:
  input.12 = input;
  D.25096 = *input.12;
  if (D.25096 == 45) goto <D.25118>; else goto <D.25119>;
  <D.25118>:
  input.12 = input;
  input.13 = input.12 + 1;
  input = input.13;
  D.25099 = 8;
  return D.25099;
  <D.25119>:
  input.12 = input;
  D.25096 = *input.12;
  D.25120 = is_filenamechar (D.25096);
  if (D.25120 != 0) goto <D.25121>; else goto <D.25122>;
  <D.25121>:
  get_string ();
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = value;
      D.25126 = "all";
      D.25127 = MEM[(const unsigned char *)D.25126];
      D.25128 = (int) D.25127;
      D.25129 = *__s2;
      D.25130 = (int) D.25129;
      __result = D.25128 - D.25130;
      {
        D.25131 = __s2_len != 0;
        D.25132 = __result == 0;
        D.25133 = D.25131 & D.25132;
        if (D.25133 != 0) goto <D.25134>; else goto <D.25135>;
        <D.25134>:
        D.25136 = &MEM[(void *)"all" + 1B];
        D.25137 = *D.25136;
        D.25138 = (int) D.25137;
        D.25139 = __s2 + 1;
        D.25140 = *D.25139;
        D.25141 = (int) D.25140;
        __result = D.25138 - D.25141;
        D.25142 = __s2_len > 1;
        D.25132 = __result == 0;
        D.25143 = D.25142 & D.25132;
        if (D.25143 != 0) goto <D.25144>; else goto <D.25145>;
        <D.25144>:
        D.25146 = &MEM[(void *)"all" + 2B];
        D.25147 = *D.25146;
        D.25148 = (int) D.25147;
        D.25149 = __s2 + 2;
        D.25150 = *D.25149;
        D.25151 = (int) D.25150;
        __result = D.25148 - D.25151;
        D.25152 = __s2_len > 2;
        D.25132 = __result == 0;
        D.25153 = D.25152 & D.25132;
        if (D.25153 != 0) goto <D.25154>; else goto <D.25155>;
        <D.25154>:
        D.25156 = &MEM[(void *)"all" + 3B];
        D.25157 = *D.25156;
        D.25158 = (int) D.25157;
        D.25159 = __s2 + 3;
        D.25160 = *D.25159;
        D.25161 = (int) D.25160;
        __result = D.25158 - D.25161;
        <D.25155>:
        <D.25145>:
        <D.25135>:
      }
      D.24643 = __result;
    }
    iftmp.15 = -D.24643;
    goto <D.25162>;
    <D.25125>:
    value.16 = value;
    iftmp.15 = __builtin_strcmp (value.16, "all");
    <D.25162>:
    D.24644 = iftmp.15;
  }
  if (D.24644 == 0) goto <D.25164>; else goto <D.25165>;
  <D.25164>:
  D.25099 = 2;
  return D.25099;
  <D.25165>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = value;
      D.25169 = "program";
      D.25170 = MEM[(const unsigned char *)D.25169];
      D.25171 = (int) D.25170;
      D.25172 = *__s2;
      D.25173 = (int) D.25172;
      __result = D.25171 - D.25173;
      {
        D.25174 = __s2_len != 0;
        D.25175 = __result == 0;
        D.25176 = D.25174 & D.25175;
        if (D.25176 != 0) goto <D.25177>; else goto <D.25178>;
        <D.25177>:
        D.25179 = &MEM[(void *)"program" + 1B];
        D.25180 = *D.25179;
        D.25181 = (int) D.25180;
        D.25182 = __s2 + 1;
        D.25183 = *D.25182;
        D.25184 = (int) D.25183;
        __result = D.25181 - D.25184;
        D.25185 = __s2_len > 1;
        D.25175 = __result == 0;
        D.25186 = D.25185 & D.25175;
        if (D.25186 != 0) goto <D.25187>; else goto <D.25188>;
        <D.25187>:
        D.25189 = &MEM[(void *)"program" + 2B];
        D.25190 = *D.25189;
        D.25191 = (int) D.25190;
        D.25192 = __s2 + 2;
        D.25193 = *D.25192;
        D.25194 = (int) D.25193;
        __result = D.25191 - D.25194;
        D.25195 = __s2_len > 2;
        D.25175 = __result == 0;
        D.25196 = D.25195 & D.25175;
        if (D.25196 != 0) goto <D.25197>; else goto <D.25198>;
        <D.25197>:
        D.25199 = &MEM[(void *)"program" + 3B];
        D.25200 = *D.25199;
        D.25201 = (int) D.25200;
        D.25202 = __s2 + 3;
        D.25203 = *D.25202;
        D.25204 = (int) D.25203;
        __result = D.25201 - D.25204;
        <D.25198>:
        <D.25188>:
        <D.25178>:
      }
      D.24652 = __result;
    }
    iftmp.17 = -D.24652;
    goto <D.25205>;
    <D.25168>:
    value.16 = value;
    iftmp.17 = __builtin_strcmp (value.16, "program");
    <D.25205>:
    D.24653 = iftmp.17;
  }
  if (D.24653 == 0) goto <D.25206>; else goto <D.25207>;
  <D.25206>:
  D.25099 = 3;
  return D.25099;
  <D.25207>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = value;
      D.25211 = "wrapper";
      D.25212 = MEM[(const unsigned char *)D.25211];
      D.25213 = (int) D.25212;
      D.25214 = *__s2;
      D.25215 = (int) D.25214;
      __result = D.25213 - D.25215;
      {
        D.25216 = __s2_len != 0;
        D.25217 = __result == 0;
        D.25218 = D.25216 & D.25217;
        if (D.25218 != 0) goto <D.25219>; else goto <D.25220>;
        <D.25219>:
        D.25221 = &MEM[(void *)"wrapper" + 1B];
        D.25222 = *D.25221;
        D.25223 = (int) D.25222;
        D.25224 = __s2 + 1;
        D.25225 = *D.25224;
        D.25226 = (int) D.25225;
        __result = D.25223 - D.25226;
        D.25227 = __s2_len > 1;
        D.25217 = __result == 0;
        D.25228 = D.25227 & D.25217;
        if (D.25228 != 0) goto <D.25229>; else goto <D.25230>;
        <D.25229>:
        D.25231 = &MEM[(void *)"wrapper" + 2B];
        D.25232 = *D.25231;
        D.25233 = (int) D.25232;
        D.25234 = __s2 + 2;
        D.25235 = *D.25234;
        D.25236 = (int) D.25235;
        __result = D.25233 - D.25236;
        D.25237 = __s2_len > 2;
        D.25217 = __result == 0;
        D.25238 = D.25237 & D.25217;
        if (D.25238 != 0) goto <D.25239>; else goto <D.25240>;
        <D.25239>:
        D.25241 = &MEM[(void *)"wrapper" + 3B];
        D.25242 = *D.25241;
        D.25243 = (int) D.25242;
        D.25244 = __s2 + 3;
        D.25245 = *D.25244;
        D.25246 = (int) D.25245;
        __result = D.25243 - D.25246;
        <D.25240>:
        <D.25230>:
        <D.25220>:
      }
      D.24661 = __result;
    }
    iftmp.18 = -D.24661;
    goto <D.25247>;
    <D.25210>:
    value.16 = value;
    iftmp.18 = __builtin_strcmp (value.16, "wrapper");
    <D.25247>:
    D.24662 = iftmp.18;
  }
  if (D.24662 == 0) goto <D.25248>; else goto <D.25249>;
  <D.25248>:
  D.25099 = 6;
  return D.25099;
  <D.25249>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = value;
      D.25253 = "disabled";
      D.25254 = MEM[(const unsigned char *)D.25253];
      D.25255 = (int) D.25254;
      D.25256 = *__s2;
      D.25257 = (int) D.25256;
      __result = D.25255 - D.25257;
      {
        D.25258 = __s2_len != 0;
        D.25259 = __result == 0;
        D.25260 = D.25258 & D.25259;
        if (D.25260 != 0) goto <D.25261>; else goto <D.25262>;
        <D.25261>:
        D.25263 = &MEM[(void *)"disabled" + 1B];
        D.25264 = *D.25263;
        D.25265 = (int) D.25264;
        D.25266 = __s2 + 1;
        D.25267 = *D.25266;
        D.25268 = (int) D.25267;
        __result = D.25265 - D.25268;
        D.25269 = __s2_len > 1;
        D.25259 = __result == 0;
        D.25270 = D.25269 & D.25259;
        if (D.25270 != 0) goto <D.25271>; else goto <D.25272>;
        <D.25271>:
        D.25273 = &MEM[(void *)"disabled" + 2B];
        D.25274 = *D.25273;
        D.25275 = (int) D.25274;
        D.25276 = __s2 + 2;
        D.25277 = *D.25276;
        D.25278 = (int) D.25277;
        __result = D.25275 - D.25278;
        D.25279 = __s2_len > 2;
        D.25259 = __result == 0;
        D.25280 = D.25279 & D.25259;
        if (D.25280 != 0) goto <D.25281>; else goto <D.25282>;
        <D.25281>:
        D.25283 = &MEM[(void *)"disabled" + 3B];
        D.25284 = *D.25283;
        D.25285 = (int) D.25284;
        D.25286 = __s2 + 3;
        D.25287 = *D.25286;
        D.25288 = (int) D.25287;
        __result = D.25285 - D.25288;
        <D.25282>:
        <D.25272>:
        <D.25262>:
      }
      D.24670 = __result;
    }
    iftmp.19 = -D.24670;
    goto <D.25289>;
    <D.25252>:
    value.16 = value;
    iftmp.19 = __builtin_strcmp (value.16, "disabled");
    <D.25289>:
    D.24671 = iftmp.19;
  }
  if (D.24671 == 0) goto <D.25290>; else goto <D.25291>;
  <D.25290>:
  D.25099 = 9;
  return D.25099;
  <D.25291>:
  D.25099 = 7;
  return D.25099;
  <D.25122>:
  input.12 = input;
  D.25096 = *input.12;
  if (D.25096 == 44) goto <D.25292>; else goto <D.25293>;
  <D.25292>:
  input.12 = input;
  input.13 = input.12 + 1;
  input = input.13;
  D.25099 = 10;
  return D.25099;
  <D.25293>:
  stderr.20 = stderr;
  input.12 = input;
  fprintf (stderr.20, "Syntax error at or around \'%s\'\n", input.12);
  D.25099 = 12;
  return D.25099;
}


is_filenamechar (char p)
{
  char D.25296;
  int D.25299;
  char D.25300;
  char D.25303;
  _Bool D.25308;
  _Bool D.25309;
  _Bool D.25310;
  _Bool D.25312;
  _Bool D.25313;
  _Bool D.25314;

  D.25296 = p + 191;
  if (D.25296 <= 25) goto <D.25297>; else goto <D.25298>;
  <D.25297>:
  D.25299 = 1;
  return D.25299;
  <D.25298>:
  D.25300 = p + 159;
  if (D.25300 <= 25) goto <D.25301>; else goto <D.25302>;
  <D.25301>:
  D.25299 = 1;
  return D.25299;
  <D.25302>:
  D.25303 = p + 208;
  if (D.25303 <= 9) goto <D.25304>; else goto <D.25305>;
  <D.25304>:
  D.25299 = 1;
  return D.25299;
  <D.25305>:
  D.25308 = p == 46;
  D.25309 = p == 58;
  D.25310 = D.25308 | D.25309;
  if (D.25310 != 0) goto <D.25306>; else goto <D.25311>;
  <D.25311>:
  D.25312 = p == 95;
  D.25313 = p == 45;
  D.25314 = D.25312 | D.25313;
  if (D.25314 != 0) goto <D.25306>; else goto <D.25307>;
  <D.25306>:
  D.25299 = 1;
  return D.25299;
  <D.25307>:
  D.25299 = 0;
  return D.25299;
}


get_string ()
{
  char * input.21;
  char * input.22;
  char D.25318;
  int D.25319;
  char * value.23;
  int input.24;
  int start.25;
  int D.25325;
  int D.25326;
  unsigned int D.25327;
  void * value.26;
  unsigned int D.25329;
  sizetype D.25330;
  char * D.25331;
  char * start;

  start = input;
  goto <D.24614>;
  <D.24613>:
  input.21 = input;
  input.22 = input.21 + 1;
  input = input.22;
  <D.24614>:
  input.21 = input;
  D.25318 = *input.21;
  D.25319 = is_filenamechar (D.25318);
  if (D.25319 != 0) goto <D.24613>; else goto <D.24615>;
  <D.24615>:
  value.23 = value;
  if (value.23 != 0B) goto <D.25321>; else goto <D.25322>;
  <D.25321>:
  value.23 = value;
  monoeg_g_free (value.23);
  <D.25322>:
  input.21 = input;
  input.24 = (int) input.21;
  start.25 = (int) start;
  D.25325 = input.24 - start.25;
  D.25326 = D.25325 + 1;
  D.25327 = (unsigned int) D.25326;
  value.26 = monoeg_malloc (D.25327);
  value = value.26;
  value.23 = value;
  input.21 = input;
  input.24 = (int) input.21;
  start.25 = (int) start;
  D.25325 = input.24 - start.25;
  D.25329 = (unsigned int) D.25325;
  strncpy (value.23, start, D.25329);
  value.23 = value;
  input.21 = input;
  input.24 = (int) input.21;
  start.25 = (int) start;
  D.25325 = input.24 - start.25;
  D.25330 = (sizetype) D.25325;
  D.25331 = value.23 + D.25330;
  *D.25331 = 0;
}


strncpy (char * restrict __dest, const char * restrict __src, size_t __len)
{
  char * D.25332;
  unsigned int D.25333;

  D.25333 = __builtin_object_size (__dest, 1);
  D.25332 = __builtin___strncpy_chk (__dest, __src, __len, D.25333);
  return D.25332;
}


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

  if (str != 0B) goto <D.25335>; else goto <D.25336>;
  <D.25335>:
  D.25337 = __strdup (str);
  return D.25337;
  <D.25336>:
  D.25337 = 0B;
  return D.25337;
}


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

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


cleanup ()
{
  char * value.27;

  value.27 = value;
  if (value.27 != 0B) goto <D.25342>; else goto <D.25343>;
  <D.25342>:
  value.27 = value;
  monoeg_g_free (value.27);
  <D.25343>:
}


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


mono_trace_enter_method (struct MonoMethod * method, char * ebp)
{
  int D.25344;
  void * D.25349;
  void * D.25350;
  short unsigned int D.25351;
  int D.25352;
  int D.25353;
  unsigned int D.25354;
  unsigned int D.25355;
  unsigned char D.25356;
  unsigned char D.25357;
  struct MonoDomain * D.25360;
  void * D.25361;
  void * D.25362;
  gboolean * D.25369;
  gboolean * D.25371;
  struct MonoMethodSignature * D.25372;
  struct MonoType * D.25373;
  int D.25374;
  struct MonoMethodSignature * D.25377;
  struct MonoType * D.25378;
  unsigned char D.25379;
  unsigned char D.25380;
  _Bool D.25381;
  long int D.25382;
  long int D.25383;
  void * * D.25386;
  void * D.25387;
  struct MonoMethodSignature * D.25388;
  unsigned char D.25389;
  unsigned char D.25390;
  short unsigned int D.25393;
  sizetype D.25394;
  struct MonoClass * D.25395;
  unsigned char D.25396;
  unsigned char D.25397;
  void * * D.25400;
  struct MonoVTable * D.25404;
  struct MonoClass * D.25405;
  const char * D.25409;
  const char * D.25410;
  struct MonoDomain * D.25411;
  char * D.25412;
  sizetype i.28;
  sizetype D.25415;
  sizetype D.25416;
  struct MonoJitArgumentInfo * D.25417;
  short unsigned int D.25418;
  sizetype D.25419;
  short unsigned int D.25420;
  struct MonoMethodSignature * D.25421;
  unsigned char D.25422;
  unsigned char D.25423;
  void * * D.25426;
  struct MonoType * D.25428;
  unsigned char D.25429;
  int D.25430;
  signed char D.25431;
  int D.25432;
  short int D.25433;
  int D.25434;
  int D.25435;
  struct MonoVTable * D.25438;
  struct MonoClass * D.25439;
  _Bool D.25440;
  long int D.25441;
  long int D.25442;
  struct MonoClass * D.25451;
  gint32 * D.25454;
  int D.25455;
  struct MonoClass * D.25457;
  struct MonoType * D.25460;
  char * D.25461;
  void * D.25464;
  long long int D.25465;
  float D.25466;
  double D.25467;
  double D.25468;
  sizetype j.29;
  guint8 * D.25470;
  unsigned char D.25471;
  int D.25472;
  struct MonoMethodSignature * D.25473;
  short unsigned int D.25474;
  int D.25475;
  struct _IO_FILE * stdout.30;
  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.25344 = trace_spec.enabled;
  if (D.25344 == 0) goto <D.25345>; else goto <D.25346>;
  <D.25345>:
  return;
  <D.25346>:
  fname = mono_method_full_name (method, 1);
  indent (1);
  printf ("ENTER: %s(", fname);
  monoeg_g_free (fname);
  if (ebp == 0B) goto <D.25347>; else goto <D.25348>;
  <D.25347>:
  D.25349 = __builtin_return_address (1);
  D.25350 = __builtin_extract_return_addr (D.25349);
  printf (") ip: %p\n", D.25350);
  return;
  <D.25348>:
  sig = mono_method_signature (method);
  D.25351 = sig->param_count;
  D.25352 = (int) D.25351;
  D.25353 = D.25352 + 1;
  D.25354 = (unsigned int) D.25353;
  D.25355 = D.25354 * 6;
  arg_info = __builtin_alloca (D.25355);
  D.25356 = BIT_FIELD_REF <*method, 8, 168>;
  D.25357 = D.25356 & 16;
  if (D.25357 != 0) goto <D.25358>; else goto <D.25359>;
  <D.25358>:
  {
    struct MonoJitInfo * ji;

    D.25360 = mono_domain_get ();
    D.25361 = __builtin_return_address (0);
    D.25362 = __builtin_extract_return_addr (D.25361);
    ji = mini_jit_info_table_find (D.25360, D.25362, 0B);
    if (ji != 0B) goto <D.25363>; else goto <D.25364>;
    <D.25363>:
    gsctx = mono_jit_info_get_generic_sharing_context (ji);
    if (gsctx != 0B) goto <D.25367>; else goto <D.25368>;
    <D.25367>:
    D.25369 = gsctx->var_is_vt;
    if (D.25369 != 0B) goto <D.25365>; else goto <D.25370>;
    <D.25370>:
    D.25371 = gsctx->mvar_is_vt;
    if (D.25371 != 0B) goto <D.25365>; else goto <D.25366>;
    <D.25365>:
    printf (") <gsharedvt>\n");
    return;
    <D.25366>:
    <D.25368>:
    <D.25364>:
  }
  <D.25359>:
  D.25351 = sig->param_count;
  D.25352 = (int) D.25351;
  mono_arch_get_argument_info (gsctx, sig, D.25352, arg_info);
  D.25372 = mono_method_signature (method);
  D.25373 = D.25372->ret;
  D.25374 = mono_type_is_struct (D.25373);
  if (D.25374 != 0) goto <D.25375>; else goto <D.25376>;
  <D.25375>:
  D.25377 = mono_method_signature (method);
  D.25378 = D.25377->ret;
  D.25379 = BIT_FIELD_REF <*D.25378, 8, 56>;
  D.25380 = D.25379 & 64;
  D.25381 = D.25380 != 0;
  D.25382 = (long int) D.25381;
  D.25383 = __builtin_expect (D.25382, 0);
  if (D.25383 != 0) goto <D.25384>; else goto <D.25385>;
  <D.25384>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "trace.c", 430, "!mono_method_signature (method)->ret->byref");
  <D.25385>:
  D.25386 = ebp + 8;
  D.25387 = *D.25386;
  printf ("VALUERET:%p, ", D.25387);
  <D.25376>:
  D.25388 = mono_method_signature (method);
  D.25389 = BIT_FIELD_REF <*D.25388, 8, 80>;
  D.25390 = D.25389 & 64;
  if (D.25390 != 0) goto <D.25391>; else goto <D.25392>;
  <D.25391>:
  {
    void * * this;

    D.25393 = arg_info->offset;
    D.25394 = (sizetype) D.25393;
    this = ebp + D.25394;
    D.25395 = method->klass;
    D.25396 = BIT_FIELD_REF <*D.25395, 8, 160>;
    D.25397 = D.25396 & 8;
    if (D.25397 != 0) goto <D.25398>; else goto <D.25399>;
    <D.25398>:
    D.25400 = MEM[(void * * *)this];
    printf ("value:%p, ", D.25400);
    goto <D.25401>;
    <D.25399>:
    o = MEM[(struct MonoObject * *)this];
    if (o != 0B) goto <D.25402>; else goto <D.25403>;
    <D.25402>:
    D.25404 = o->vtable;
    class = D.25404->klass;
    D.25405 = mono_defaults.string_class;
    if (D.25405 == class) goto <D.25406>; else goto <D.25407>;
    <D.25406>:
    {
      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.25408>;
    <D.25407>:
    D.25409 = class->name_space;
    D.25410 = class->name;
    D.25404 = o->vtable;
    D.25411 = D.25404->domain;
    D.25412 = D.25411->friendly_name;
    printf ("this:%p[%s.%s %s], ", o, D.25409, D.25410, D.25412);
    <D.25408>:
    goto <D.25413>;
    <D.25403>:
    printf ("this:NULL, ");
    <D.25413>:
    <D.25401>:
  }
  <D.25392>:
  i = 0;
  goto <D.24761>;
  <D.24760>:
  {
    void * * cpos;
    int size;
    struct MonoType * type;

    i.28 = (sizetype) i;
    D.25415 = i.28 + 1;
    D.25416 = D.25415 * 6;
    D.25417 = arg_info + D.25416;
    D.25418 = D.25417->offset;
    D.25419 = (sizetype) D.25418;
    cpos = ebp + D.25419;
    i.28 = (sizetype) i;
    D.25415 = i.28 + 1;
    D.25416 = D.25415 * 6;
    D.25417 = arg_info + D.25416;
    D.25420 = D.25417->size;
    size = (int) D.25420;
    D.25421 = mono_method_signature (method);
    type = D.25421->params[i];
    D.25422 = BIT_FIELD_REF <*type, 8, 56>;
    D.25423 = D.25422 & 64;
    if (D.25423 != 0) goto <D.25424>; else goto <D.25425>;
    <D.25424>:
    D.25426 = MEM[(void * * *)cpos];
    printf ("[BYREF:%p], ", D.25426);
    goto <D.25427>;
    <D.25425>:
    D.25428 = mono_type_get_underlying_type (type);
    D.25429 = D.25428->type;
    D.25430 = (int) D.25429;
    switch (D.25430) <default: <D.24759>, case 2: <D.24733>, case 3: <D.24734>, case 4: <D.24735>, case 5: <D.24736>, case 6: <D.24737>, case 7: <D.24738>, case 8: <D.24739>, case 9: <D.24740>, case 10: <D.24751>, case 11: <D.24752>, case 12: <D.24753>, case 13: <D.24754>, case 14: <D.24741>, case 15: <D.24747>, case 17: <D.24755>, case 18: <D.24744>, case 20: <D.24749>, case 24: <D.24730>, case 25: <D.24731>, case 27: <D.24748>, case 28: <D.24745>, case 29: <D.24750>>
    <D.24730>:
    <D.24731>:
    D.25426 = MEM[(void * * *)cpos];
    printf ("%p, ", D.25426);
    goto <D.24732>;
    <D.24733>:
    <D.24734>:
    <D.24735>:
    <D.24736>:
    D.25431 = MEM[(gint8 *)cpos];
    D.25432 = (int) D.25431;
    printf ("%d, ", D.25432);
    goto <D.24732>;
    <D.24737>:
    <D.24738>:
    D.25433 = MEM[(gint16 *)cpos];
    D.25434 = (int) D.25433;
    printf ("%d, ", D.25434);
    goto <D.24732>;
    <D.24739>:
    <D.24740>:
    D.25435 = MEM[(int *)cpos];
    printf ("%d, ", D.25435);
    goto <D.24732>;
    <D.24741>:
    {
      struct MonoString * s;

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

        D.25438 = MEM[(struct MonoObject *)s].vtable;
        D.25439 = D.25438->klass;
        D.25405 = mono_defaults.string_class;
        D.25440 = D.25439 != D.25405;
        D.25441 = (long int) D.25440;
        D.25442 = __builtin_expect (D.25441, 0);
        if (D.25442 != 0) goto <D.25443>; else goto <D.25444>;
        <D.25443>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "trace.c", 492, "((MonoObject *)s)->vtable->klass == mono_defaults.string_class");
        <D.25444>:
        as = string_to_utf8 (s);
        printf ("[STRING:%p:%s], ", s, as);
        monoeg_g_free (as);
      }
      goto <D.25445>;
      <D.25437>:
      printf ("[STRING:null], ");
      <D.25445>:
      goto <D.24732>;
    }
    <D.24744>:
    <D.24745>:
    o = MEM[(struct MonoObject * *)cpos];
    if (o != 0B) goto <D.25446>; else goto <D.25447>;
    <D.25446>:
    D.25404 = o->vtable;
    class = D.25404->klass;
    D.25405 = mono_defaults.string_class;
    if (D.25405 == class) goto <D.25448>; else goto <D.25449>;
    <D.25448>:
    {
      char * as;

      as = string_to_utf8 (o);
      printf ("[STRING:%p:%s], ", o, as);
      monoeg_g_free (as);
    }
    goto <D.25450>;
    <D.25449>:
    D.25451 = mono_defaults.int32_class;
    if (D.25451 == class) goto <D.25452>; else goto <D.25453>;
    <D.25452>:
    D.25454 = o + 8;
    D.25455 = *D.25454;
    printf ("[INT32:%p:%d], ", o, D.25455);
    goto <D.25456>;
    <D.25453>:
    D.25457 = mono_defaults.monotype_class;
    if (D.25457 == class) goto <D.25458>; else goto <D.25459>;
    <D.25458>:
    D.25460 = MEM[(struct MonoReflectionType *)o].type;
    D.25461 = mono_type_full_name (D.25460);
    printf ("[TYPE:%s], ", D.25461);
    goto <D.25462>;
    <D.25459>:
    D.25409 = class->name_space;
    D.25410 = class->name;
    printf ("[%s.%s:%p], ", D.25409, D.25410, o);
    <D.25462>:
    <D.25456>:
    <D.25450>:
    goto <D.25463>;
    <D.25447>:
    D.25464 = *cpos;
    printf ("%p, ", D.25464);
    <D.25463>:
    goto <D.24732>;
    <D.24747>:
    <D.24748>:
    <D.24749>:
    <D.24750>:
    D.25464 = *cpos;
    printf ("%p, ", D.25464);
    goto <D.24732>;
    <D.24751>:
    <D.24752>:
    D.25465 = MEM[(gint64 *)cpos];
    printf ("0x%016llx, ", D.25465);
    goto <D.24732>;
    <D.24753>:
    D.25466 = MEM[(float *)cpos];
    D.25467 = (double) D.25466;
    printf ("%f, ", D.25467);
    goto <D.24732>;
    <D.24754>:
    D.25468 = MEM[(double *)cpos];
    printf ("%f, ", D.25468);
    goto <D.24732>;
    <D.24755>:
    printf ("[");
    j = 0;
    goto <D.24757>;
    <D.24756>:
    j.29 = (sizetype) j;
    D.25470 = cpos + j.29;
    D.25471 = *D.25470;
    D.25472 = (int) D.25471;
    printf ("%02x,", D.25472);
    j = j + 1;
    <D.24757>:
    if (j < size) goto <D.24756>; else goto <D.24758>;
    <D.24758>:
    printf ("], ");
    goto <D.24732>;
    <D.24759>:
    printf ("XX, ");
    <D.24732>:
    <D.25427>:
  }
  i = i + 1;
  <D.24761>:
  D.25473 = mono_method_signature (method);
  D.25474 = D.25473->param_count;
  D.25475 = (int) D.25474;
  if (D.25475 > i) goto <D.24760>; else goto <D.24762>;
  <D.24762>:
  printf (")\n");
  stdout.30 = stdout;
  fflush (stdout.30);
}


indent (int diff)
{
  int indent_level.31;
  int indent_level.32;
  long long unsigned int start_time.33;
  long long int D.25485;
  long long unsigned int start_time.34;
  unsigned int D.25487;
  void * D.25488;
  double D.25489;

  if (diff < 0) goto <D.25478>; else goto <D.25479>;
  <D.25478>:
  indent_level.31 = indent_level;
  indent_level.32 = indent_level.31 + diff;
  indent_level = indent_level.32;
  <D.25479>:
  start_time.33 = start_time;
  if (start_time.33 == 0) goto <D.25483>; else goto <D.25484>;
  <D.25483>:
  D.25485 = mono_100ns_ticks ();
  start_time.34 = (long long unsigned int) D.25485;
  start_time = start_time.34;
  <D.25484>:
  D.25487 = GetCurrentThreadId ();
  D.25488 = (void *) D.25487;
  D.25489 = seconds_since_start ();
  indent_level.31 = indent_level;
  printf ("[%p: %.5f %d] ", D.25488, D.25489, indent_level.31);
  if (diff > 0) goto <D.25490>; else goto <D.25491>;
  <D.25490>:
  indent_level.31 = indent_level;
  indent_level.32 = indent_level.31 + diff;
  indent_level = indent_level.32;
  <D.25491>:
}


seconds_since_start ()
{
  long long int D.25492;
  long long unsigned int D.25493;
  long long unsigned int start_time.35;
  double D.25495;
  double D.25496;
  guint64 diff;

  D.25492 = mono_100ns_ticks ();
  D.25493 = (long long unsigned int) D.25492;
  start_time.35 = start_time;
  diff = D.25493 - start_time.35;
  D.25496 = (double) diff;
  D.25495 = D.25496 / 1.0e+7;
  return D.25495;
}


string_to_utf8 (struct MonoString * s)
{
  _Bool D.25498;
  long int D.25499;
  long int D.25500;
  int D.25503;
  char * D.25506;
  mono_unichar2 * D.25507;
  struct GError * error.36;
  char * as;
  struct GError * error;

  try
    {
      error = 0B;
      D.25498 = s == 0B;
      D.25499 = (long int) D.25498;
      D.25500 = __builtin_expect (D.25499, 0);
      if (D.25500 != 0) goto <D.25501>; else goto <D.25502>;
      <D.25501>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "trace.c", 355, "s");
      <D.25502>:
      D.25503 = s->length;
      if (D.25503 == 0) goto <D.25504>; else goto <D.25505>;
      <D.25504>:
      D.25506 = monoeg_strdup ("");
      return D.25506;
      <D.25505>:
      D.25507 = mono_string_chars (s);
      D.25503 = s->length;
      as = monoeg_g_utf16_to_utf8 (D.25507, D.25503, 0B, 0B, &error);
      error.36 = error;
      if (error.36 != 0B) goto <D.25509>; else goto <D.25510>;
      <D.25509>:
      error.36 = error;
      monoeg_g_error_free (error.36);
      D.25506 = monoeg_strdup ("<INVALID UTF8>");
      return D.25506;
      <D.25510>:
      D.25506 = as;
      return D.25506;
    }
  finally
    {
      error = {CLOBBER};
    }
}


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

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


mono_trace_leave_method (struct MonoMethod * method)
{
  int D.25515;
  unsigned char D.25518;
  unsigned char D.25519;
  struct MonoDomain * D.25522;
  void * D.25523;
  void * D.25524;
  gboolean * D.25531;
  gboolean * D.25533;
  struct MonoMethodSignature * D.25534;
  unsigned char D.25535;
  int D.25536;
  void * D.25537;
  void * D.25538;
  void * D.25542;
  void * D.25543;
  void * D.25544;
  void * D.25545;
  struct MonoVTable * D.25548;
  struct MonoClass * D.25549;
  struct MonoClass * D.25550;
  _Bool D.25551;
  long int D.25552;
  long int D.25553;
  void * D.25557;
  void * D.25558;
  struct MonoVTable * D.25561;
  struct MonoClass * D.25562;
  struct MonoClass * D.25563;
  guint8 * D.25566;
  unsigned char D.25567;
  int D.25568;
  struct MonoClass * D.25570;
  gint32 * D.25573;
  int D.25574;
  struct MonoClass * D.25576;
  gint64 * D.25579;
  long long int D.25580;
  const char * D.25582;
  const char * D.25583;
  void * D.25585;
  void * D.25586;
  void * D.25587;
  void * D.25588;
  void * D.25589;
  void * D.25590;
  void * D.25591;
  void * D.25592;
  struct MonoClass * D.25593;
  unsigned char D.25594;
  unsigned char D.25595;
  void * D.25598;
  void * D.25599;
  sizetype j.37;
  guint8 * D.25601;
  unsigned char D.25602;
  int D.25603;
  _Bool D.25604;
  _Bool D.25605;
  _Bool D.25606;
  struct MonoMethodSignature * D.25607;
  struct MonoType * D.25608;
  unsigned char D.25609;
  int D.25610;
  struct _IO_FILE * stdout.38;
  struct MonoType * type;
  char * fname;
  struct va_list ap;
  struct MonoGenericSharingContext * gsctx;
  void handle_enum = <<< error >>>;

  try
    {
      D.25515 = trace_spec.enabled;
      if (D.25515 == 0) goto <D.25516>; else goto <D.25517>;
      <D.25516>:
      return;
      <D.25517>:
      __builtin_va_start (&ap, 0);
      fname = mono_method_full_name (method, 1);
      indent (-1);
      printf ("LEAVE: %s", fname);
      monoeg_g_free (fname);
      D.25518 = BIT_FIELD_REF <*method, 8, 168>;
      D.25519 = D.25518 & 16;
      if (D.25519 != 0) goto <D.25520>; else goto <D.25521>;
      <D.25520>:
      {
        struct MonoJitInfo * ji;

        D.25522 = mono_domain_get ();
        D.25523 = __builtin_return_address (0);
        D.25524 = __builtin_extract_return_addr (D.25523);
        ji = mini_jit_info_table_find (D.25522, D.25524, 0B);
        if (ji != 0B) goto <D.25525>; else goto <D.25526>;
        <D.25525>:
        gsctx = mono_jit_info_get_generic_sharing_context (ji);
        if (gsctx != 0B) goto <D.25529>; else goto <D.25530>;
        <D.25529>:
        D.25531 = gsctx->var_is_vt;
        if (D.25531 != 0B) goto <D.25527>; else goto <D.25532>;
        <D.25532>:
        D.25533 = gsctx->mvar_is_vt;
        if (D.25533 != 0B) goto <D.25527>; else goto <D.25528>;
        <D.25527>:
        printf (") <gsharedvt>\n");
        return;
        <D.25528>:
        <D.25530>:
        <D.25526>:
      }
      <D.25521>:
      D.25534 = mono_method_signature (method);
      type = D.25534->ret;
      handle_enum:
      D.25535 = type->type;
      D.25536 = (int) D.25535;
      switch (D.25536) <default: <D.24812>, case 1: <D.24772>, case 2: <D.24774>, case 3: <D.24776>, case 4: <D.24777>, case 5: <D.24778>, case 6: <D.24779>, case 7: <D.24780>, case 8: <D.24781>, case 9: <D.24782>, case 10: <D.24797>, case 11: <D.24799>, case 12: <D.24801>, case 13: <D.24802>, case 14: <D.24786>, case 15: <D.24792>, case 17: <D.24804>, case 18: <D.24789>, case 20: <D.24794>, case 24: <D.24783>, case 25: <D.24784>, case 27: <D.24793>, case 28: <D.24790>, case 29: <D.24795>>
      <D.24772>:
      goto <D.24773>;
      <D.24774>:
      {
        int eax;

        D.25537 = ap.__ap;
        D.25538 = D.25537 + 4;
        ap.__ap = D.25538;
        eax = MEM[(int *)D.25537];
        if (eax != 0) goto <D.25539>; else goto <D.25540>;
        <D.25539>:
        printf ("TRUE:%d", eax);
        goto <D.25541>;
        <D.25540>:
        printf ("FALSE");
        <D.25541>:
        goto <D.24773>;
      }
      <D.24776>:
      <D.24777>:
      <D.24778>:
      <D.24779>:
      <D.24780>:
      <D.24781>:
      <D.24782>:
      <D.24783>:
      <D.24784>:
      {
        int eax;

        D.25542 = ap.__ap;
        D.25543 = D.25542 + 4;
        ap.__ap = D.25543;
        eax = MEM[(int *)D.25542];
        printf ("result=%d", eax);
        goto <D.24773>;
      }
      <D.24786>:
      {
        struct MonoString * s;

        D.25544 = ap.__ap;
        D.25545 = D.25544 + 4;
        ap.__ap = D.25545;
        s = MEM[(struct MonoString * *)D.25544];
        if (s != 0B) goto <D.25546>; else goto <D.25547>;
        <D.25546>:
        {
          char * as;

          D.25548 = MEM[(struct MonoObject *)s].vtable;
          D.25549 = D.25548->klass;
          D.25550 = mono_defaults.string_class;
          D.25551 = D.25549 != D.25550;
          D.25552 = (long int) D.25551;
          D.25553 = __builtin_expect (D.25552, 0);
          if (D.25553 != 0) goto <D.25554>; else goto <D.25555>;
          <D.25554>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "trace.c", 619, "((MonoObject *)s)->vtable->klass == mono_defaults.string_class");
          <D.25555>:
          as = string_to_utf8 (s);
          printf ("[STRING:%p:%s]", s, as);
          monoeg_g_free (as);
        }
        goto <D.25556>;
        <D.25547>:
        printf ("[STRING:null], ");
        <D.25556>:
        goto <D.24773>;
      }
      <D.24789>:
      <D.24790>:
      {
        struct MonoObject * o;

        D.25557 = ap.__ap;
        D.25558 = D.25557 + 4;
        ap.__ap = D.25558;
        o = MEM[(struct MonoObject * *)D.25557];
        if (o != 0B) goto <D.25559>; else goto <D.25560>;
        <D.25559>:
        D.25561 = o->vtable;
        D.25562 = D.25561->klass;
        D.25563 = mono_defaults.boolean_class;
        if (D.25562 == D.25563) goto <D.25564>; else goto <D.25565>;
        <D.25564>:
        D.25566 = o + 8;
        D.25567 = *D.25566;
        D.25568 = (int) D.25567;
        printf ("[BOOLEAN:%p:%d]", o, D.25568);
        goto <D.25569>;
        <D.25565>:
        D.25561 = o->vtable;
        D.25562 = D.25561->klass;
        D.25570 = mono_defaults.int32_class;
        if (D.25562 == D.25570) goto <D.25571>; else goto <D.25572>;
        <D.25571>:
        D.25573 = o + 8;
        D.25574 = *D.25573;
        printf ("[INT32:%p:%d]", o, D.25574);
        goto <D.25575>;
        <D.25572>:
        D.25561 = o->vtable;
        D.25562 = D.25561->klass;
        D.25576 = mono_defaults.int64_class;
        if (D.25562 == D.25576) goto <D.25577>; else goto <D.25578>;
        <D.25577>:
        D.25579 = o + 8;
        D.25580 = *D.25579;
        printf ("[INT64:%p:%lld]", o, D.25580);
        goto <D.25581>;
        <D.25578>:
        D.25561 = o->vtable;
        D.25562 = D.25561->klass;
        D.25582 = D.25562->name_space;
        D.25561 = o->vtable;
        D.25562 = D.25561->klass;
        D.25583 = D.25562->name;
        printf ("[%s.%s:%p]", D.25582, D.25583, o);
        <D.25581>:
        <D.25575>:
        <D.25569>:
        goto <D.25584>;
        <D.25560>:
        printf ("[OBJECT:%p]", o);
        <D.25584>:
        goto <D.24773>;
      }
      <D.24792>:
      <D.24793>:
      <D.24794>:
      <D.24795>:
      {
        void * p;

        D.25585 = ap.__ap;
        D.25586 = D.25585 + 4;
        ap.__ap = D.25586;
        p = MEM[(void * *)D.25585];
        printf ("result=%p", p);
        goto <D.24773>;
      }
      <D.24797>:
      {
        gint64 l;

        D.25587 = ap.__ap;
        D.25587 = D.25587 + 7;
        D.25587 = D.25587 & 4294967288B;
        D.25588 = D.25587 + 8;
        ap.__ap = D.25588;
        l = MEM[(gint64 *)D.25587];
        printf ("lresult=0x%16llx", l);
        goto <D.24773>;
      }
      <D.24799>:
      {
        gint64 l;

        D.25589 = ap.__ap;
        D.25589 = D.25589 + 7;
        D.25589 = D.25589 & 4294967288B;
        D.25590 = D.25589 + 8;
        ap.__ap = D.25590;
        l = MEM[(gint64 *)D.25589];
        printf ("lresult=0x%16llx", l);
        goto <D.24773>;
      }
      <D.24801>:
      <D.24802>:
      {
        double f;

        D.25591 = ap.__ap;
        D.25591 = D.25591 + 7;
        D.25591 = D.25591 & 4294967288B;
        D.25592 = D.25591 + 8;
        ap.__ap = D.25592;
        f = MEM[(double *)D.25591];
        printf ("FP=%f", f);
        goto <D.24773>;
      }
      <D.24804>:
      D.25593 = type->data.klass;
      D.25594 = BIT_FIELD_REF <*D.25593, 8, 160>;
      D.25595 = D.25594 & 16;
      if (D.25595 != 0) goto <D.25596>; else goto <D.25597>;
      <D.25596>:
      D.25593 = type->data.klass;
      type = mono_class_enum_basetype (D.25593);
      goto handle_enum;
      <D.25597>:
      {
        guint8 * p;
        int j;
        int size;
        int align;

        try
          {
            D.25598 = ap.__ap;
            D.25599 = D.25598 + 4;
            ap.__ap = D.25599;
            p = MEM[(void * *)D.25598];
            size = mono_type_size (type, &align);
            printf ("[");
            j = 0;
            goto <D.24810>;
            <D.24809>:
            j.37 = (sizetype) j;
            D.25601 = p + j.37;
            D.25602 = *D.25601;
            D.25603 = (int) D.25602;
            printf ("%02x,", D.25603);
            j = j + 1;
            <D.24810>:
            D.25604 = p != 0B;
            D.25605 = j < size;
            D.25606 = D.25604 & D.25605;
            if (D.25606 != 0) goto <D.24809>; else goto <D.24811>;
            <D.24811>:
            printf ("]");
          }
        finally
          {
            align = {CLOBBER};
          }
      }
      goto <D.24773>;
      <D.24812>:
      D.25607 = mono_method_signature (method);
      D.25608 = D.25607->ret;
      D.25609 = D.25608->type;
      D.25610 = (int) D.25609;
      printf ("(unknown return type %x)", D.25610);
      <D.24773>:
      printf ("\n");
      stdout.38 = stdout;
      fflush (stdout.38);
    }
  finally
    {
      ap = {CLOBBER};
    }
}


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


mono_trace_is_enabled ()
{
  gboolean D.25616;

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