mono_trace_eval_exception (struct MonoClass * klass)
{
  gboolean D.22309;
  struct MonoTraceOperation * D.22310;
  unsigned int i.0;
  unsigned int D.22312;
  <unnamed type> D.22313;
  int D.21995;
  int iftmp.1;
  int D.21991;
  const char[1] * D.22319;
  unsigned char D.22320;
  int D.22321;
  unsigned char D.22322;
  int D.22323;
  _Bool D.22324;
  _Bool D.22325;
  _Bool D.22326;
  const unsigned char * D.22329;
  unsigned char D.22330;
  int D.22331;
  const unsigned char * D.22332;
  unsigned char D.22333;
  int D.22334;
  _Bool D.22335;
  _Bool D.22336;
  const unsigned char * D.22339;
  unsigned char D.22340;
  int D.22341;
  const unsigned char * D.22342;
  unsigned char D.22343;
  int D.22344;
  _Bool D.22345;
  _Bool D.22346;
  const unsigned char * D.22349;
  unsigned char D.22350;
  int D.22351;
  const unsigned char * D.22352;
  unsigned char D.22353;
  int D.22354;
  void * D.22356;
  unsigned char D.22357;
  int D.22358;
  int D.22004;
  int iftmp.2;
  int D.22000;
  const char[4] * D.22363;
  unsigned char D.22364;
  int D.22365;
  unsigned char D.22366;
  int D.22367;
  _Bool D.22368;
  _Bool D.22369;
  _Bool D.22370;
  const unsigned char * D.22373;
  unsigned char D.22374;
  int D.22375;
  const unsigned char * D.22376;
  unsigned char D.22377;
  int D.22378;
  _Bool D.22379;
  _Bool D.22380;
  const unsigned char * D.22383;
  unsigned char D.22384;
  int D.22385;
  const unsigned char * D.22386;
  unsigned char D.22387;
  int D.22388;
  _Bool D.22389;
  _Bool D.22390;
  const unsigned char * D.22393;
  unsigned char D.22394;
  int D.22395;
  const unsigned char * D.22396;
  unsigned char D.22397;
  int D.22398;
  void * D.22400;
  int D.22013;
  int iftmp.3;
  int D.22009;
  unsigned char D.22407;
  int D.22408;
  _Bool D.22409;
  _Bool D.22410;
  _Bool D.22411;
  const unsigned char * D.22414;
  unsigned char D.22415;
  int D.22416;
  _Bool D.22417;
  _Bool D.22418;
  const unsigned char * D.22421;
  unsigned char D.22422;
  int D.22423;
  _Bool D.22424;
  _Bool D.22425;
  const unsigned char * D.22428;
  unsigned char D.22429;
  int D.22430;
  int D.22022;
  const char * D.22433;
  int D.22031;
  const char * D.22434;
  int D.22437;
  int D.22445;
  int include;
  int i;

  include = 0;
  if (klass == 0B) goto <D.22307>; else goto <D.22308>;
  <D.22307>:
  D.22309 = 0;
  return D.22309;
  <D.22308>:
  i = 0;
  goto <D.22035>;
  <D.22034>:
  {
    struct MonoTraceOperation * op;
    int inc;

    D.22310 = trace_spec.ops;
    i.0 = (unsigned int) i;
    D.22312 = i.0 * 16;
    op = D.22310 + D.22312;
    inc = 0;
    D.22313 = op->op;
    switch (D.22313) <default: <D.22033>, case 6: <D.21986>>
    <D.21986>:
    {
      size_t __s1_len;
      size_t __s2_len;

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

        __s2 = op->data;
        D.22319 = "";
        D.22320 = MEM[(const unsigned char *)D.22319];
        D.22321 = (int) D.22320;
        D.22322 = *__s2;
        D.22323 = (int) D.22322;
        __result = D.22321 - D.22323;
        {
          D.22324 = __s1_len != 0;
          D.22325 = __result == 0;
          D.22326 = D.22324 & D.22325;
          if (D.22326 != 0) goto <D.22327>; else goto <D.22328>;
          <D.22327>:
          D.22329 = &MEM[(void *)"" + 1B];
          D.22330 = *D.22329;
          D.22331 = (int) D.22330;
          D.22332 = __s2 + 1;
          D.22333 = *D.22332;
          D.22334 = (int) D.22333;
          __result = D.22331 - D.22334;
          D.22335 = __s1_len > 1;
          D.22325 = __result == 0;
          D.22336 = D.22335 & D.22325;
          if (D.22336 != 0) goto <D.22337>; else goto <D.22338>;
          <D.22337>:
          D.22339 = &MEM[(void *)"" + 2B];
          D.22340 = *D.22339;
          D.22341 = (int) D.22340;
          D.22342 = __s2 + 2;
          D.22343 = *D.22342;
          D.22344 = (int) D.22343;
          __result = D.22341 - D.22344;
          D.22345 = __s1_len > 2;
          D.22325 = __result == 0;
          D.22346 = D.22345 & D.22325;
          if (D.22346 != 0) goto <D.22347>; else goto <D.22348>;
          <D.22347>:
          D.22349 = &MEM[(void *)"" + 3B];
          D.22350 = *D.22349;
          D.22351 = (int) D.22350;
          D.22352 = __s2 + 3;
          D.22353 = *D.22352;
          D.22354 = (int) D.22353;
          __result = D.22351 - D.22354;
          <D.22348>:
          <D.22338>:
          <D.22328>:
        }
        D.21991 = __result;
      }
      iftmp.1 = D.21991;
      goto <D.22355>;
      <D.22318>:
      D.22356 = op->data;
      D.22357 = MEM[(const unsigned char * {ref-all})D.22356];
      D.22358 = (int) D.22357;
      iftmp.1 = -D.22358;
      <D.22355>:
      D.21995 = iftmp.1;
    }
    if (D.21995 == 0) goto <D.22359>; else goto <D.22314>;
    <D.22359>:
    {
      size_t __s1_len;
      size_t __s2_len;

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

        __s2 = op->data2;
        D.22363 = "all";
        D.22364 = MEM[(const unsigned char *)D.22363];
        D.22365 = (int) D.22364;
        D.22366 = *__s2;
        D.22367 = (int) D.22366;
        __result = D.22365 - D.22367;
        {
          D.22368 = __s1_len != 0;
          D.22369 = __result == 0;
          D.22370 = D.22368 & D.22369;
          if (D.22370 != 0) goto <D.22371>; else goto <D.22372>;
          <D.22371>:
          D.22373 = &MEM[(void *)"all" + 1B];
          D.22374 = *D.22373;
          D.22375 = (int) D.22374;
          D.22376 = __s2 + 1;
          D.22377 = *D.22376;
          D.22378 = (int) D.22377;
          __result = D.22375 - D.22378;
          D.22379 = __s1_len > 1;
          D.22369 = __result == 0;
          D.22380 = D.22379 & D.22369;
          if (D.22380 != 0) goto <D.22381>; else goto <D.22382>;
          <D.22381>:
          D.22383 = &MEM[(void *)"all" + 2B];
          D.22384 = *D.22383;
          D.22385 = (int) D.22384;
          D.22386 = __s2 + 2;
          D.22387 = *D.22386;
          D.22388 = (int) D.22387;
          __result = D.22385 - D.22388;
          D.22389 = __s1_len > 2;
          D.22369 = __result == 0;
          D.22390 = D.22389 & D.22369;
          if (D.22390 != 0) goto <D.22391>; else goto <D.22392>;
          <D.22391>:
          D.22393 = &MEM[(void *)"all" + 3B];
          D.22394 = *D.22393;
          D.22395 = (int) D.22394;
          D.22396 = __s2 + 3;
          D.22397 = *D.22396;
          D.22398 = (int) D.22397;
          __result = D.22395 - D.22398;
          <D.22392>:
          <D.22382>:
          <D.22372>:
        }
        D.22000 = __result;
      }
      iftmp.2 = D.22000;
      goto <D.22399>;
      <D.22362>:
      D.22400 = op->data2;
      iftmp.2 = __builtin_strcmp ("all", D.22400);
      <D.22399>:
      D.22004 = iftmp.2;
    }
    if (D.22004 == 0) goto <D.22401>; else goto <D.22314>;
    <D.22401>:
    inc = 1;
    goto <D.22315>;
    <D.22314>:
    {
      size_t __s1_len;
      size_t __s2_len;

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

        __s2 = op->data;
        D.22319 = "";
        D.22320 = MEM[(const unsigned char *)D.22319];
        D.22321 = (int) D.22320;
        D.22407 = *__s2;
        D.22408 = (int) D.22407;
        __result = D.22321 - D.22408;
        {
          D.22409 = __s1_len != 0;
          D.22410 = __result == 0;
          D.22411 = D.22409 & D.22410;
          if (D.22411 != 0) goto <D.22412>; else goto <D.22413>;
          <D.22412>:
          D.22329 = &MEM[(void *)"" + 1B];
          D.22330 = *D.22329;
          D.22331 = (int) D.22330;
          D.22414 = __s2 + 1;
          D.22415 = *D.22414;
          D.22416 = (int) D.22415;
          __result = D.22331 - D.22416;
          D.22417 = __s1_len > 1;
          D.22410 = __result == 0;
          D.22418 = D.22417 & D.22410;
          if (D.22418 != 0) goto <D.22419>; else goto <D.22420>;
          <D.22419>:
          D.22339 = &MEM[(void *)"" + 2B];
          D.22340 = *D.22339;
          D.22341 = (int) D.22340;
          D.22421 = __s2 + 2;
          D.22422 = *D.22421;
          D.22423 = (int) D.22422;
          __result = D.22341 - D.22423;
          D.22424 = __s1_len > 2;
          D.22410 = __result == 0;
          D.22425 = D.22424 & D.22410;
          if (D.22425 != 0) goto <D.22426>; else goto <D.22427>;
          <D.22426>:
          D.22349 = &MEM[(void *)"" + 3B];
          D.22350 = *D.22349;
          D.22351 = (int) D.22350;
          D.22428 = __s2 + 3;
          D.22429 = *D.22428;
          D.22430 = (int) D.22429;
          __result = D.22351 - D.22430;
          <D.22427>:
          <D.22420>:
          <D.22413>:
        }
        D.22009 = __result;
      }
      iftmp.3 = D.22009;
      goto <D.22431>;
      <D.22406>:
      D.22356 = op->data;
      D.22357 = MEM[(const unsigned char * {ref-all})D.22356];
      D.22358 = (int) D.22357;
      iftmp.3 = -D.22358;
      <D.22431>:
      D.22013 = iftmp.3;
    }
    if (D.22013 == 0) goto <D.22402>; else goto <D.22432>;
    <D.22432>:
    {
      size_t __s1_len;
      size_t __s2_len;

      D.22356 = op->data;
      D.22433 = klass->name_space;
      D.22022 = __builtin_strcmp (D.22433, D.22356);
    }
    if (D.22022 == 0) goto <D.22402>; else goto <D.22403>;
    <D.22402>:
    {
      size_t __s1_len;
      size_t __s2_len;

      D.22400 = op->data2;
      D.22434 = klass->name;
      D.22031 = __builtin_strcmp (D.22434, D.22400);
    }
    if (D.22031 == 0) goto <D.22435>; else goto <D.22436>;
    <D.22435>:
    inc = 1;
    <D.22436>:
    <D.22403>:
    <D.22315>:
    goto <D.22032>;
    <D.22033>:
    goto <D.22032>;
    <D.22032>:
    D.22437 = op->exclude;
    if (D.22437 != 0) goto <D.22438>; else goto <D.22439>;
    <D.22438>:
    if (inc != 0) goto <D.22440>; else goto <D.22441>;
    <D.22440>:
    include = 0;
    <D.22441>:
    goto <D.22442>;
    <D.22439>:
    if (inc != 0) goto <D.22443>; else goto <D.22444>;
    <D.22443>:
    include = 1;
    <D.22444>:
    <D.22442>:
  }
  i = i + 1;
  <D.22035>:
  D.22445 = trace_spec.len;
  if (D.22445 > i) goto <D.22034>; else goto <D.22036>;
  <D.22036>:
  D.22309 = include;
  return D.22309;
}


mono_trace_eval (struct MonoMethod * method)
{
  struct MonoTraceOperation * D.22448;
  unsigned int i.4;
  unsigned int D.22450;
  <unnamed type> D.22451;
  struct MonoAssembly * D.22452;
  struct MonoClass * D.22455;
  struct MonoImage * D.22456;
  struct MonoImage * D.22457;
  unsigned char D.22460;
  unsigned char D.22461;
  _Bool D.22462;
  _Bool D.22463;
  _Bool D.22464;
  void * D.22467;
  int D.22468;
  int D.22058;
  const char * D.22471;
  int D.22067;
  void * D.22474;
  const char * D.22475;
  int D.22077;
  const char * D.22478;
  int D.22087;
  int D.22484;
  int D.22492;
  gboolean D.22493;
  int include;
  int i;

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

    D.22448 = trace_spec.ops;
    i.4 = (unsigned int) i;
    D.22450 = i.4 * 16;
    op = D.22448 + D.22450;
    inc = 0;
    D.22451 = op->op;
    switch (D.22451) <default: <D.22483>, case 0: <D.22044>, case 1: <D.22046>, case 2: <D.22048>, case 3: <D.22068>, case 4: <D.22049>, case 5: <D.22078>, case 6: <D.22088>, case 7: <D.22047>>
    <D.22044>:
    inc = 1;
    goto <D.22045>;
    <D.22046>:
    D.22452 = trace_spec.assembly;
    if (D.22452 != 0B) goto <D.22453>; else goto <D.22454>;
    <D.22453>:
    D.22455 = method->klass;
    D.22456 = D.22455->image;
    D.22452 = trace_spec.assembly;
    D.22457 = mono_assembly_get_image (D.22452);
    if (D.22456 == D.22457) goto <D.22458>; else goto <D.22459>;
    <D.22458>:
    inc = 1;
    <D.22459>:
    <D.22454>:
    goto <D.22045>;
    <D.22047>:
    D.22460 = BIT_FIELD_REF <*method, 8, 160>;
    D.22461 = D.22460 & 124;
    D.22462 = D.22461 == 20;
    D.22463 = D.22461 == 24;
    D.22464 = D.22462 | D.22463;
    if (D.22464 != 0) goto <D.22465>; else goto <D.22466>;
    <D.22465>:
    inc = 1;
    <D.22466>:
    goto <D.22045>;
    <D.22048>:
    D.22467 = op->data;
    D.22468 = mono_method_desc_full_match (D.22467, method);
    if (D.22468 != 0) goto <D.22469>; else goto <D.22470>;
    <D.22469>:
    inc = 1;
    <D.22470>:
    goto <D.22045>;
    <D.22049>:
    {
      size_t __s1_len;
      size_t __s2_len;

      D.22467 = op->data;
      D.22455 = method->klass;
      D.22471 = D.22455->name_space;
      D.22058 = __builtin_strcmp (D.22471, D.22467);
    }
    if (D.22058 == 0) goto <D.22472>; else goto <D.22473>;
    <D.22472>:
    {
      size_t __s1_len;
      size_t __s2_len;

      D.22474 = op->data2;
      D.22455 = method->klass;
      D.22475 = D.22455->name;
      D.22067 = __builtin_strcmp (D.22475, D.22474);
    }
    if (D.22067 == 0) goto <D.22476>; else goto <D.22477>;
    <D.22476>:
    inc = 1;
    <D.22477>:
    <D.22473>:
    goto <D.22045>;
    <D.22068>:
    {
      size_t __s1_len;
      size_t __s2_len;

      D.22467 = op->data;
      D.22455 = method->klass;
      D.22456 = D.22455->image;
      D.22478 = mono_image_get_name (D.22456);
      D.22077 = __builtin_strcmp (D.22478, D.22467);
    }
    if (D.22077 == 0) goto <D.22479>; else goto <D.22480>;
    <D.22479>:
    inc = 1;
    <D.22480>:
    goto <D.22045>;
    <D.22078>:
    {
      size_t __s1_len;
      size_t __s2_len;

      D.22467 = op->data;
      D.22455 = method->klass;
      D.22471 = D.22455->name_space;
      D.22087 = __builtin_strcmp (D.22471, D.22467);
    }
    if (D.22087 == 0) goto <D.22481>; else goto <D.22482>;
    <D.22481>:
    inc = 1;
    <D.22482>:
    <D.22088>:
    goto <D.22045>;
    <D.22483>:
    <D.22045>:
    D.22484 = op->exclude;
    if (D.22484 != 0) goto <D.22485>; else goto <D.22486>;
    <D.22485>:
    if (inc != 0) goto <D.22487>; else goto <D.22488>;
    <D.22487>:
    include = 0;
    <D.22488>:
    goto <D.22489>;
    <D.22486>:
    if (inc != 0) goto <D.22490>; else goto <D.22491>;
    <D.22490>:
    include = 1;
    <D.22491>:
    <D.22489>:
  }
  i = i + 1;
  <D.22090>:
  D.22492 = trace_spec.len;
  if (D.22492 > i) goto <D.22089>; else goto <D.22091>;
  <D.22091>:
  D.22493 = include;
  return D.22493;
}


mono_trace_parse_options (const char * options)
{
  char D.22495;
  void * D.22498;
  struct MonoTraceOperation * D.22499;
  struct MonoTraceSpec * D.22500;
  unsigned int size.5;
  unsigned int D.22504;
  void * D.22505;
  int last_used.6;
  char * p;
  int size;
  int last_used;
  int token;

  try
    {
      p = options;
      size = 1;
      trace_spec.enabled = 1;
      D.22495 = *p;
      if (D.22495 == 0) goto <D.22496>; else goto <D.22497>;
      <D.22496>:
      trace_spec.len = 1;
      D.22498 = monoeg_malloc0 (16);
      trace_spec.ops = D.22498;
      D.22499 = trace_spec.ops;
      D.22499->op = 0;
      D.22500 = &trace_spec;
      return D.22500;
      <D.22497>:
      p = options;
      goto <D.22177>;
      <D.22176>:
      D.22495 = *p;
      if (D.22495 == 44) goto <D.22501>; else goto <D.22502>;
      <D.22501>:
      size = size + 1;
      <D.22502>:
      p = p + 1;
      <D.22177>:
      D.22495 = *p;
      if (D.22495 != 0) goto <D.22176>; else goto <D.22178>;
      <D.22178>:
      size.5 = (unsigned int) size;
      D.22504 = size.5 * 16;
      D.22505 = monoeg_malloc0 (D.22504);
      trace_spec.ops = D.22505;
      input = options;
      last_used = 0;
      goto <D.22179>;
      <D.22180>:
      if (token == 12) goto <D.22506>; else goto <D.22507>;
      <D.22506>:
      D.22500 = 0B;
      return D.22500;
      <D.22507>:
      if (token == 10) goto <D.22508>; else goto <D.22509>;
      <D.22508>:
      // predicted unlikely by continue predictor.
      goto <D.22179>;
      <D.22509>:
      <D.22179>:
      token = get_spec (&last_used);
      if (token != 11) goto <D.22180>; else goto <D.22181>;
      <D.22181>:
      last_used.6 = last_used;
      trace_spec.len = last_used.6;
      cleanup ();
      D.22500 = &trace_spec;
      return D.22500;
    }
  finally
    {
      last_used = {CLOBBER};
    }
}


get_spec (int * last)
{
  struct _IO_FILE * stderr.7;
  int D.22518;
  struct MonoTraceOperation * D.22521;
  int D.22522;
  sizetype D.22523;
  sizetype D.22524;
  sizetype D.22525;
  struct MonoTraceOperation * D.22526;
  unsigned int token.8;
  unsigned int D.22528;
  char * value.9;
  unsigned int D.22536;
  unsigned int D.22537;
  struct MonoTraceOperation * D.22538;
  gchar * D.22551;
  _Bool D.22553;
  _Bool D.22554;
  _Bool D.22555;
  char * p.10;
  gchar * D.22561;
  gchar * D.22562;
  gchar * D.22564;
  gchar * D.22565;
  MonoTraceOpcode iftmp.11;
  gchar * D.22573;
  int D.22578;
  int token;

  token = get_token ();
  if (token == 8) goto <D.22513>; else goto <D.22514>;
  <D.22513>:
  token = get_spec (last);
  if (token == 8) goto <D.22515>; else goto <D.22516>;
  <D.22515>:
  stderr.7 = stderr;
  fprintf (stderr.7, "Expecting an expression");
  D.22518 = 12;
  return D.22518;
  <D.22516>:
  if (token == 12) goto <D.22519>; else goto <D.22520>;
  <D.22519>:
  D.22518 = token;
  return D.22518;
  <D.22520>:
  D.22521 = trace_spec.ops;
  D.22522 = *last;
  D.22523 = (sizetype) D.22522;
  D.22524 = D.22523 + 268435455;
  D.22525 = D.22524 * 16;
  D.22526 = D.22521 + D.22525;
  D.22526->exclude = 1;
  D.22518 = 10;
  return D.22518;
  <D.22514>:
  token.8 = (unsigned int) token;
  D.22528 = token.8 + 4294967286;
  if (D.22528 <= 2) goto <D.22529>; else goto <D.22530>;
  <D.22529>:
  D.22518 = token;
  return D.22518;
  <D.22530>:
  if (token == 0) goto <D.22531>; else goto <D.22532>;
  <D.22531>:
  {
    struct MonoMethodDesc * desc;

    value.9 = value;
    desc = mono_method_desc_new (value.9, 1);
    if (desc == 0B) goto <D.22534>; else goto <D.22535>;
    <D.22534>:
    value.9 = value;
    stderr.7 = stderr;
    fprintf (stderr.7, "Invalid method name: %s\n", value.9);
    D.22518 = 12;
    return D.22518;
    <D.22535>:
    D.22521 = trace_spec.ops;
    D.22522 = *last;
    D.22536 = (unsigned int) D.22522;
    D.22537 = D.22536 * 16;
    D.22538 = D.22521 + D.22537;
    D.22538->op = 2;
    D.22521 = trace_spec.ops;
    D.22522 = *last;
    D.22536 = (unsigned int) D.22522;
    D.22537 = D.22536 * 16;
    D.22538 = D.22521 + D.22537;
    D.22538->data = desc;
  }
  goto <D.22539>;
  <D.22532>:
  if (token == 2) goto <D.22540>; else goto <D.22541>;
  <D.22540>:
  D.22521 = trace_spec.ops;
  D.22522 = *last;
  D.22536 = (unsigned int) D.22522;
  D.22537 = D.22536 * 16;
  D.22538 = D.22521 + D.22537;
  D.22538->op = 0;
  goto <D.22542>;
  <D.22541>:
  if (token == 3) goto <D.22543>; else goto <D.22544>;
  <D.22543>:
  D.22521 = trace_spec.ops;
  D.22522 = *last;
  D.22536 = (unsigned int) D.22522;
  D.22537 = D.22536 * 16;
  D.22538 = D.22521 + D.22537;
  D.22538->op = 1;
  goto <D.22545>;
  <D.22544>:
  if (token == 6) goto <D.22546>; else goto <D.22547>;
  <D.22546>:
  D.22521 = trace_spec.ops;
  D.22522 = *last;
  D.22536 = (unsigned int) D.22522;
  D.22537 = D.22536 * 16;
  D.22538 = D.22521 + D.22537;
  D.22538->op = 7;
  goto <D.22548>;
  <D.22547>:
  if (token == 5) goto <D.22549>; else goto <D.22550>;
  <D.22549>:
  D.22521 = trace_spec.ops;
  D.22522 = *last;
  D.22536 = (unsigned int) D.22522;
  D.22537 = D.22536 * 16;
  D.22538 = D.22521 + D.22537;
  D.22538->op = 5;
  D.22521 = trace_spec.ops;
  D.22522 = *last;
  D.22536 = (unsigned int) D.22522;
  D.22537 = D.22536 * 16;
  D.22538 = D.22521 + D.22537;
  value.9 = value;
  D.22551 = monoeg_strdup (value.9);
  D.22538->data = D.22551;
  goto <D.22552>;
  <D.22550>:
  D.22553 = token == 1;
  D.22554 = token == 4;
  D.22555 = D.22553 | D.22554;
  if (D.22555 != 0) goto <D.22556>; else goto <D.22557>;
  <D.22556>:
  {
    char * p;

    value.9 = value;
    p = strrchr (value.9, 46);
    if (p != 0B) goto <D.22558>; else goto <D.22559>;
    <D.22558>:
    p.10 = p;
    p = p.10 + 1;
    *p.10 = 0;
    D.22521 = trace_spec.ops;
    D.22522 = *last;
    D.22536 = (unsigned int) D.22522;
    D.22537 = D.22536 * 16;
    D.22538 = D.22521 + D.22537;
    value.9 = value;
    D.22561 = monoeg_strdup (value.9);
    D.22538->data = D.22561;
    D.22521 = trace_spec.ops;
    D.22522 = *last;
    D.22536 = (unsigned int) D.22522;
    D.22537 = D.22536 * 16;
    D.22538 = D.22521 + D.22537;
    D.22562 = monoeg_strdup (p);
    D.22538->data2 = D.22562;
    goto <D.22563>;
    <D.22559>:
    D.22521 = trace_spec.ops;
    D.22522 = *last;
    D.22536 = (unsigned int) D.22522;
    D.22537 = D.22536 * 16;
    D.22538 = D.22521 + D.22537;
    D.22564 = monoeg_strdup ("");
    D.22538->data = D.22564;
    D.22521 = trace_spec.ops;
    D.22522 = *last;
    D.22536 = (unsigned int) D.22522;
    D.22537 = D.22536 * 16;
    D.22538 = D.22521 + D.22537;
    value.9 = value;
    D.22565 = monoeg_strdup (value.9);
    D.22538->data2 = D.22565;
    <D.22563>:
    D.22521 = trace_spec.ops;
    D.22522 = *last;
    D.22536 = (unsigned int) D.22522;
    D.22537 = D.22536 * 16;
    D.22538 = D.22521 + D.22537;
    if (token == 1) goto <D.22567>; else goto <D.22568>;
    <D.22567>:
    iftmp.11 = 4;
    goto <D.22569>;
    <D.22568>:
    iftmp.11 = 6;
    <D.22569>:
    D.22538->op = iftmp.11;
  }
  goto <D.22570>;
  <D.22557>:
  if (token == 7) goto <D.22571>; else goto <D.22572>;
  <D.22571>:
  D.22521 = trace_spec.ops;
  D.22522 = *last;
  D.22536 = (unsigned int) D.22522;
  D.22537 = D.22536 * 16;
  D.22538 = D.22521 + D.22537;
  D.22538->op = 3;
  D.22521 = trace_spec.ops;
  D.22522 = *last;
  D.22536 = (unsigned int) D.22522;
  D.22537 = D.22536 * 16;
  D.22538 = D.22521 + D.22537;
  value.9 = value;
  D.22573 = monoeg_strdup (value.9);
  D.22538->data = D.22573;
  goto <D.22574>;
  <D.22572>:
  if (token == 9) goto <D.22575>; else goto <D.22576>;
  <D.22575>:
  trace_spec.enabled = 0;
  goto <D.22577>;
  <D.22576>:
  stderr.7 = stderr;
  fprintf (stderr.7, "Syntax error in trace option specification\n");
  D.22518 = 12;
  return D.22518;
  <D.22577>:
  <D.22574>:
  <D.22570>:
  <D.22552>:
  <D.22548>:
  <D.22545>:
  <D.22542>:
  <D.22539>:
  D.22522 = *last;
  D.22578 = D.22522 + 1;
  *last = D.22578;
  D.22518 = 10;
  return D.22518;
}


get_token ()
{
  char * input.12;
  char * input.13;
  char D.22582;
  int D.22585;
  char D.22588;
  char * input.14;
  int D.22606;
  int D.22607;
  int D.22132;
  int iftmp.15;
  int D.22131;
  const char[4] * D.22613;
  unsigned char D.22614;
  int D.22615;
  unsigned char D.22616;
  int D.22617;
  _Bool D.22618;
  _Bool D.22619;
  _Bool D.22620;
  const unsigned char * D.22623;
  unsigned char D.22624;
  int D.22625;
  const unsigned char * D.22626;
  unsigned char D.22627;
  int D.22628;
  _Bool D.22629;
  _Bool D.22630;
  const unsigned char * D.22633;
  unsigned char D.22634;
  int D.22635;
  const unsigned char * D.22636;
  unsigned char D.22637;
  int D.22638;
  _Bool D.22639;
  _Bool D.22640;
  const unsigned char * D.22643;
  unsigned char D.22644;
  int D.22645;
  const unsigned char * D.22646;
  unsigned char D.22647;
  int D.22648;
  char * value.16;
  int D.22141;
  int iftmp.17;
  int D.22140;
  const char[8] * D.22656;
  unsigned char D.22657;
  int D.22658;
  unsigned char D.22659;
  int D.22660;
  _Bool D.22661;
  _Bool D.22662;
  _Bool D.22663;
  const unsigned char * D.22666;
  unsigned char D.22667;
  int D.22668;
  const unsigned char * D.22669;
  unsigned char D.22670;
  int D.22671;
  _Bool D.22672;
  _Bool D.22673;
  const unsigned char * D.22676;
  unsigned char D.22677;
  int D.22678;
  const unsigned char * D.22679;
  unsigned char D.22680;
  int D.22681;
  _Bool D.22682;
  _Bool D.22683;
  const unsigned char * D.22686;
  unsigned char D.22687;
  int D.22688;
  const unsigned char * D.22689;
  unsigned char D.22690;
  int D.22691;
  int D.22150;
  int iftmp.18;
  int D.22149;
  const char[8] * D.22698;
  unsigned char D.22699;
  int D.22700;
  unsigned char D.22701;
  int D.22702;
  _Bool D.22703;
  _Bool D.22704;
  _Bool D.22705;
  const unsigned char * D.22708;
  unsigned char D.22709;
  int D.22710;
  const unsigned char * D.22711;
  unsigned char D.22712;
  int D.22713;
  _Bool D.22714;
  _Bool D.22715;
  const unsigned char * D.22718;
  unsigned char D.22719;
  int D.22720;
  const unsigned char * D.22721;
  unsigned char D.22722;
  int D.22723;
  _Bool D.22724;
  _Bool D.22725;
  const unsigned char * D.22728;
  unsigned char D.22729;
  int D.22730;
  const unsigned char * D.22731;
  unsigned char D.22732;
  int D.22733;
  int D.22159;
  int iftmp.19;
  int D.22158;
  const char[9] * D.22740;
  unsigned char D.22741;
  int D.22742;
  unsigned char D.22743;
  int D.22744;
  _Bool D.22745;
  _Bool D.22746;
  _Bool D.22747;
  const unsigned char * D.22750;
  unsigned char D.22751;
  int D.22752;
  const unsigned char * D.22753;
  unsigned char D.22754;
  int D.22755;
  _Bool D.22756;
  _Bool D.22757;
  const unsigned char * D.22760;
  unsigned char D.22761;
  int D.22762;
  const unsigned char * D.22763;
  unsigned char D.22764;
  int D.22765;
  _Bool D.22766;
  _Bool D.22767;
  const unsigned char * D.22770;
  unsigned char D.22771;
  int D.22772;
  const unsigned char * D.22773;
  unsigned char D.22774;
  int D.22775;
  struct _IO_FILE * stderr.20;

  goto <D.22122>;
  <D.22121>:
  input.12 = input;
  input.13 = input.12 + 1;
  input = input.13;
  <D.22122>:
  input.12 = input;
  D.22582 = *input.12;
  if (D.22582 == 43) goto <D.22121>; else goto <D.22123>;
  <D.22123>:
  input.12 = input;
  D.22582 = *input.12;
  if (D.22582 == 0) goto <D.22583>; else goto <D.22584>;
  <D.22583>:
  D.22585 = 11;
  return D.22585;
  <D.22584>:
  input.12 = input;
  D.22582 = *input.12;
  if (D.22582 == 77) goto <D.22586>; else goto <D.22587>;
  <D.22586>:
  input.12 = input;
  input.13 = input.12 + 1;
  D.22588 = *input.13;
  if (D.22588 == 58) goto <D.22589>; else goto <D.22590>;
  <D.22589>:
  input.12 = input;
  input.14 = input.12 + 2;
  input = input.14;
  get_string ();
  D.22585 = 0;
  return D.22585;
  <D.22590>:
  <D.22587>:
  input.12 = input;
  D.22582 = *input.12;
  if (D.22582 == 78) goto <D.22592>; else goto <D.22593>;
  <D.22592>:
  input.12 = input;
  input.13 = input.12 + 1;
  D.22588 = *input.13;
  if (D.22588 == 58) goto <D.22594>; else goto <D.22595>;
  <D.22594>:
  input.12 = input;
  input.14 = input.12 + 2;
  input = input.14;
  get_string ();
  D.22585 = 5;
  return D.22585;
  <D.22595>:
  <D.22593>:
  input.12 = input;
  D.22582 = *input.12;
  if (D.22582 == 84) goto <D.22596>; else goto <D.22597>;
  <D.22596>:
  input.12 = input;
  input.13 = input.12 + 1;
  D.22588 = *input.13;
  if (D.22588 == 58) goto <D.22598>; else goto <D.22599>;
  <D.22598>:
  input.12 = input;
  input.14 = input.12 + 2;
  input = input.14;
  get_string ();
  D.22585 = 1;
  return D.22585;
  <D.22599>:
  <D.22597>:
  input.12 = input;
  D.22582 = *input.12;
  if (D.22582 == 69) goto <D.22600>; else goto <D.22601>;
  <D.22600>:
  input.12 = input;
  input.13 = input.12 + 1;
  D.22588 = *input.13;
  if (D.22588 == 58) goto <D.22602>; else goto <D.22603>;
  <D.22602>:
  input.12 = input;
  input.14 = input.12 + 2;
  input = input.14;
  get_string ();
  D.22585 = 4;
  return D.22585;
  <D.22603>:
  <D.22601>:
  input.12 = input;
  D.22582 = *input.12;
  if (D.22582 == 45) goto <D.22604>; else goto <D.22605>;
  <D.22604>:
  input.12 = input;
  input.13 = input.12 + 1;
  input = input.13;
  D.22585 = 8;
  return D.22585;
  <D.22605>:
  input.12 = input;
  D.22582 = *input.12;
  D.22606 = (int) D.22582;
  D.22607 = is_filenamechar (D.22606);
  if (D.22607 != 0) goto <D.22608>; else goto <D.22609>;
  <D.22608>:
  get_string ();
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = value;
      D.22613 = "all";
      D.22614 = MEM[(const unsigned char *)D.22613];
      D.22615 = (int) D.22614;
      D.22616 = *__s2;
      D.22617 = (int) D.22616;
      __result = D.22615 - D.22617;
      {
        D.22618 = __s2_len != 0;
        D.22619 = __result == 0;
        D.22620 = D.22618 & D.22619;
        if (D.22620 != 0) goto <D.22621>; else goto <D.22622>;
        <D.22621>:
        D.22623 = &MEM[(void *)"all" + 1B];
        D.22624 = *D.22623;
        D.22625 = (int) D.22624;
        D.22626 = __s2 + 1;
        D.22627 = *D.22626;
        D.22628 = (int) D.22627;
        __result = D.22625 - D.22628;
        D.22629 = __s2_len > 1;
        D.22619 = __result == 0;
        D.22630 = D.22629 & D.22619;
        if (D.22630 != 0) goto <D.22631>; else goto <D.22632>;
        <D.22631>:
        D.22633 = &MEM[(void *)"all" + 2B];
        D.22634 = *D.22633;
        D.22635 = (int) D.22634;
        D.22636 = __s2 + 2;
        D.22637 = *D.22636;
        D.22638 = (int) D.22637;
        __result = D.22635 - D.22638;
        D.22639 = __s2_len > 2;
        D.22619 = __result == 0;
        D.22640 = D.22639 & D.22619;
        if (D.22640 != 0) goto <D.22641>; else goto <D.22642>;
        <D.22641>:
        D.22643 = &MEM[(void *)"all" + 3B];
        D.22644 = *D.22643;
        D.22645 = (int) D.22644;
        D.22646 = __s2 + 3;
        D.22647 = *D.22646;
        D.22648 = (int) D.22647;
        __result = D.22645 - D.22648;
        <D.22642>:
        <D.22632>:
        <D.22622>:
      }
      D.22131 = __result;
    }
    iftmp.15 = -D.22131;
    goto <D.22649>;
    <D.22612>:
    value.16 = value;
    iftmp.15 = __builtin_strcmp (value.16, "all");
    <D.22649>:
    D.22132 = iftmp.15;
  }
  if (D.22132 == 0) goto <D.22651>; else goto <D.22652>;
  <D.22651>:
  D.22585 = 2;
  return D.22585;
  <D.22652>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = value;
      D.22656 = "program";
      D.22657 = MEM[(const unsigned char *)D.22656];
      D.22658 = (int) D.22657;
      D.22659 = *__s2;
      D.22660 = (int) D.22659;
      __result = D.22658 - D.22660;
      {
        D.22661 = __s2_len != 0;
        D.22662 = __result == 0;
        D.22663 = D.22661 & D.22662;
        if (D.22663 != 0) goto <D.22664>; else goto <D.22665>;
        <D.22664>:
        D.22666 = &MEM[(void *)"program" + 1B];
        D.22667 = *D.22666;
        D.22668 = (int) D.22667;
        D.22669 = __s2 + 1;
        D.22670 = *D.22669;
        D.22671 = (int) D.22670;
        __result = D.22668 - D.22671;
        D.22672 = __s2_len > 1;
        D.22662 = __result == 0;
        D.22673 = D.22672 & D.22662;
        if (D.22673 != 0) goto <D.22674>; else goto <D.22675>;
        <D.22674>:
        D.22676 = &MEM[(void *)"program" + 2B];
        D.22677 = *D.22676;
        D.22678 = (int) D.22677;
        D.22679 = __s2 + 2;
        D.22680 = *D.22679;
        D.22681 = (int) D.22680;
        __result = D.22678 - D.22681;
        D.22682 = __s2_len > 2;
        D.22662 = __result == 0;
        D.22683 = D.22682 & D.22662;
        if (D.22683 != 0) goto <D.22684>; else goto <D.22685>;
        <D.22684>:
        D.22686 = &MEM[(void *)"program" + 3B];
        D.22687 = *D.22686;
        D.22688 = (int) D.22687;
        D.22689 = __s2 + 3;
        D.22690 = *D.22689;
        D.22691 = (int) D.22690;
        __result = D.22688 - D.22691;
        <D.22685>:
        <D.22675>:
        <D.22665>:
      }
      D.22140 = __result;
    }
    iftmp.17 = -D.22140;
    goto <D.22692>;
    <D.22655>:
    value.16 = value;
    iftmp.17 = __builtin_strcmp (value.16, "program");
    <D.22692>:
    D.22141 = iftmp.17;
  }
  if (D.22141 == 0) goto <D.22693>; else goto <D.22694>;
  <D.22693>:
  D.22585 = 3;
  return D.22585;
  <D.22694>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = value;
      D.22698 = "wrapper";
      D.22699 = MEM[(const unsigned char *)D.22698];
      D.22700 = (int) D.22699;
      D.22701 = *__s2;
      D.22702 = (int) D.22701;
      __result = D.22700 - D.22702;
      {
        D.22703 = __s2_len != 0;
        D.22704 = __result == 0;
        D.22705 = D.22703 & D.22704;
        if (D.22705 != 0) goto <D.22706>; else goto <D.22707>;
        <D.22706>:
        D.22708 = &MEM[(void *)"wrapper" + 1B];
        D.22709 = *D.22708;
        D.22710 = (int) D.22709;
        D.22711 = __s2 + 1;
        D.22712 = *D.22711;
        D.22713 = (int) D.22712;
        __result = D.22710 - D.22713;
        D.22714 = __s2_len > 1;
        D.22704 = __result == 0;
        D.22715 = D.22714 & D.22704;
        if (D.22715 != 0) goto <D.22716>; else goto <D.22717>;
        <D.22716>:
        D.22718 = &MEM[(void *)"wrapper" + 2B];
        D.22719 = *D.22718;
        D.22720 = (int) D.22719;
        D.22721 = __s2 + 2;
        D.22722 = *D.22721;
        D.22723 = (int) D.22722;
        __result = D.22720 - D.22723;
        D.22724 = __s2_len > 2;
        D.22704 = __result == 0;
        D.22725 = D.22724 & D.22704;
        if (D.22725 != 0) goto <D.22726>; else goto <D.22727>;
        <D.22726>:
        D.22728 = &MEM[(void *)"wrapper" + 3B];
        D.22729 = *D.22728;
        D.22730 = (int) D.22729;
        D.22731 = __s2 + 3;
        D.22732 = *D.22731;
        D.22733 = (int) D.22732;
        __result = D.22730 - D.22733;
        <D.22727>:
        <D.22717>:
        <D.22707>:
      }
      D.22149 = __result;
    }
    iftmp.18 = -D.22149;
    goto <D.22734>;
    <D.22697>:
    value.16 = value;
    iftmp.18 = __builtin_strcmp (value.16, "wrapper");
    <D.22734>:
    D.22150 = iftmp.18;
  }
  if (D.22150 == 0) goto <D.22735>; else goto <D.22736>;
  <D.22735>:
  D.22585 = 6;
  return D.22585;
  <D.22736>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = value;
      D.22740 = "disabled";
      D.22741 = MEM[(const unsigned char *)D.22740];
      D.22742 = (int) D.22741;
      D.22743 = *__s2;
      D.22744 = (int) D.22743;
      __result = D.22742 - D.22744;
      {
        D.22745 = __s2_len != 0;
        D.22746 = __result == 0;
        D.22747 = D.22745 & D.22746;
        if (D.22747 != 0) goto <D.22748>; else goto <D.22749>;
        <D.22748>:
        D.22750 = &MEM[(void *)"disabled" + 1B];
        D.22751 = *D.22750;
        D.22752 = (int) D.22751;
        D.22753 = __s2 + 1;
        D.22754 = *D.22753;
        D.22755 = (int) D.22754;
        __result = D.22752 - D.22755;
        D.22756 = __s2_len > 1;
        D.22746 = __result == 0;
        D.22757 = D.22756 & D.22746;
        if (D.22757 != 0) goto <D.22758>; else goto <D.22759>;
        <D.22758>:
        D.22760 = &MEM[(void *)"disabled" + 2B];
        D.22761 = *D.22760;
        D.22762 = (int) D.22761;
        D.22763 = __s2 + 2;
        D.22764 = *D.22763;
        D.22765 = (int) D.22764;
        __result = D.22762 - D.22765;
        D.22766 = __s2_len > 2;
        D.22746 = __result == 0;
        D.22767 = D.22766 & D.22746;
        if (D.22767 != 0) goto <D.22768>; else goto <D.22769>;
        <D.22768>:
        D.22770 = &MEM[(void *)"disabled" + 3B];
        D.22771 = *D.22770;
        D.22772 = (int) D.22771;
        D.22773 = __s2 + 3;
        D.22774 = *D.22773;
        D.22775 = (int) D.22774;
        __result = D.22772 - D.22775;
        <D.22769>:
        <D.22759>:
        <D.22749>:
      }
      D.22158 = __result;
    }
    iftmp.19 = -D.22158;
    goto <D.22776>;
    <D.22739>:
    value.16 = value;
    iftmp.19 = __builtin_strcmp (value.16, "disabled");
    <D.22776>:
    D.22159 = iftmp.19;
  }
  if (D.22159 == 0) goto <D.22777>; else goto <D.22778>;
  <D.22777>:
  D.22585 = 9;
  return D.22585;
  <D.22778>:
  D.22585 = 7;
  return D.22585;
  <D.22609>:
  input.12 = input;
  D.22582 = *input.12;
  if (D.22582 == 44) goto <D.22779>; else goto <D.22780>;
  <D.22779>:
  input.12 = input;
  input.13 = input.12 + 1;
  input = input.13;
  D.22585 = 10;
  return D.22585;
  <D.22780>:
  input.12 = input;
  stderr.20 = stderr;
  fprintf (stderr.20, "Syntax error at or around \'%s\'\n", input.12);
  D.22585 = 12;
  return D.22585;
}


is_filenamechar (char p)
{
  unsigned char p.21;
  unsigned char D.22784;
  int D.22787;
  unsigned char D.22788;
  unsigned char D.22791;
  _Bool D.22796;
  _Bool D.22797;
  _Bool D.22798;
  _Bool D.22800;
  _Bool D.22801;
  _Bool D.22802;

  p.21 = (unsigned char) p;
  D.22784 = p.21 + 191;
  if (D.22784 <= 25) goto <D.22785>; else goto <D.22786>;
  <D.22785>:
  D.22787 = 1;
  return D.22787;
  <D.22786>:
  p.21 = (unsigned char) p;
  D.22788 = p.21 + 159;
  if (D.22788 <= 25) goto <D.22789>; else goto <D.22790>;
  <D.22789>:
  D.22787 = 1;
  return D.22787;
  <D.22790>:
  p.21 = (unsigned char) p;
  D.22791 = p.21 + 208;
  if (D.22791 <= 9) goto <D.22792>; else goto <D.22793>;
  <D.22792>:
  D.22787 = 1;
  return D.22787;
  <D.22793>:
  D.22796 = p == 46;
  D.22797 = p == 58;
  D.22798 = D.22796 | D.22797;
  if (D.22798 != 0) goto <D.22794>; else goto <D.22799>;
  <D.22799>:
  D.22800 = p == 95;
  D.22801 = p == 45;
  D.22802 = D.22800 | D.22801;
  if (D.22802 != 0) goto <D.22794>; else goto <D.22795>;
  <D.22794>:
  D.22787 = 1;
  return D.22787;
  <D.22795>:
  D.22787 = 0;
  return D.22787;
}


get_string ()
{
  char * input.22;
  char * input.23;
  char D.22806;
  int D.22807;
  int D.22808;
  char * value.24;
  int input.25;
  int start.26;
  int D.22814;
  int D.22815;
  unsigned int D.22816;
  void * value.27;
  unsigned int D.22818;
  sizetype D.22819;
  char * D.22820;
  char * start;

  start = input;
  goto <D.22102>;
  <D.22101>:
  input.22 = input;
  input.23 = input.22 + 1;
  input = input.23;
  <D.22102>:
  input.22 = input;
  D.22806 = *input.22;
  D.22807 = (int) D.22806;
  D.22808 = is_filenamechar (D.22807);
  if (D.22808 != 0) goto <D.22101>; else goto <D.22103>;
  <D.22103>:
  value.24 = value;
  if (value.24 != 0B) goto <D.22810>; else goto <D.22811>;
  <D.22810>:
  value.24 = value;
  monoeg_g_free (value.24);
  <D.22811>:
  input.22 = input;
  input.25 = (int) input.22;
  start.26 = (int) start;
  D.22814 = input.25 - start.26;
  D.22815 = D.22814 + 1;
  D.22816 = (unsigned int) D.22815;
  value.27 = monoeg_malloc (D.22816);
  value = value.27;
  input.22 = input;
  input.25 = (int) input.22;
  start.26 = (int) start;
  D.22814 = input.25 - start.26;
  D.22818 = (unsigned int) D.22814;
  value.24 = value;
  strncpy (value.24, start, D.22818);
  value.24 = value;
  input.22 = input;
  input.25 = (int) input.22;
  start.26 = (int) start;
  D.22814 = input.25 - start.26;
  D.22819 = (sizetype) D.22814;
  D.22820 = value.24 + D.22819;
  *D.22820 = 0;
}


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

  D.22822 = __builtin_object_size (__dest, 1);
  D.22821 = __builtin___strncpy_chk (__dest, __src, __len, D.22822);
  return D.22821;
}


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

  if (str != 0B) goto <D.22824>; else goto <D.22825>;
  <D.22824>:
  D.22826 = __strdup (str);
  return D.22826;
  <D.22825>:
  D.22826 = 0B;
  return D.22826;
}


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

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


cleanup ()
{
  char * value.28;

  value.28 = value;
  if (value.28 != 0B) goto <D.22831>; else goto <D.22832>;
  <D.22831>:
  value.28 = value;
  monoeg_g_free (value.28);
  <D.22832>:
}


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


mono_trace_enter_method (struct MonoMethod * method, char * ebp)
{
  int D.22833;
  void * D.22838;
  void * D.22839;
  short unsigned int D.22840;
  int D.22841;
  int D.22842;
  unsigned int D.22843;
  unsigned int D.22844;
  unsigned char D.22845;
  unsigned char D.22846;
  void * D.22849;
  void * D.22850;
  struct MonoDomain * D.22851;
  gboolean * D.22858;
  gboolean * D.22860;
  struct MonoMethodSignature * D.22861;
  struct MonoType * D.22862;
  int D.22863;
  struct MonoMethodSignature * D.22866;
  struct MonoType * D.22867;
  unsigned char D.22868;
  unsigned char D.22869;
  _Bool D.22870;
  long int D.22871;
  long int D.22872;
  void * * D.22875;
  void * D.22876;
  struct MonoMethodSignature * D.22877;
  unsigned char D.22878;
  unsigned char D.22879;
  short unsigned int D.22882;
  sizetype D.22883;
  struct MonoClass * D.22884;
  unsigned char D.22885;
  unsigned char D.22886;
  void * * D.22889;
  struct MonoVTable * D.22893;
  struct MonoClass * D.22894;
  struct MonoDomain * D.22898;
  char * D.22899;
  const char * D.22900;
  const char * D.22901;
  sizetype i.29;
  sizetype D.22904;
  sizetype D.22905;
  struct MonoJitArgumentInfo * D.22906;
  short unsigned int D.22907;
  sizetype D.22908;
  short unsigned int D.22909;
  struct MonoMethodSignature * D.22910;
  unsigned char D.22911;
  unsigned char D.22912;
  void * * D.22915;
  struct MonoType * D.22917;
  unsigned char D.22918;
  int D.22919;
  signed char D.22920;
  int D.22921;
  short int D.22922;
  int D.22923;
  int D.22924;
  struct MonoVTable * D.22927;
  struct MonoClass * D.22928;
  _Bool D.22929;
  long int D.22930;
  long int D.22931;
  struct MonoClass * D.22940;
  gint32 * D.22943;
  int D.22944;
  struct MonoClass * D.22946;
  struct MonoType * D.22949;
  char * D.22950;
  void * D.22953;
  long long int D.22954;
  float D.22955;
  double D.22956;
  double D.22957;
  sizetype j.30;
  guint8 * D.22959;
  unsigned char D.22960;
  int D.22961;
  struct MonoMethodSignature * D.22962;
  short unsigned int D.22963;
  int D.22964;
  struct _IO_FILE * stdout.31;
  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.22833 = trace_spec.enabled;
  if (D.22833 == 0) goto <D.22834>; else goto <D.22835>;
  <D.22834>:
  return;
  <D.22835>:
  fname = mono_method_full_name (method, 1);
  indent (1);
  printf ("ENTER: %s(", fname);
  monoeg_g_free (fname);
  if (ebp == 0B) goto <D.22836>; else goto <D.22837>;
  <D.22836>:
  D.22838 = __builtin_return_address (1);
  D.22839 = __builtin_extract_return_addr (D.22838);
  printf (") ip: %p\n", D.22839);
  return;
  <D.22837>:
  sig = mono_method_signature (method);
  D.22840 = sig->param_count;
  D.22841 = (int) D.22840;
  D.22842 = D.22841 + 1;
  D.22843 = (unsigned int) D.22842;
  D.22844 = D.22843 * 6;
  arg_info = __builtin_alloca (D.22844);
  D.22845 = BIT_FIELD_REF <*method, 8, 168>;
  D.22846 = D.22845 & 16;
  if (D.22846 != 0) goto <D.22847>; else goto <D.22848>;
  <D.22847>:
  {
    struct MonoJitInfo * ji;

    D.22849 = __builtin_return_address (0);
    D.22850 = __builtin_extract_return_addr (D.22849);
    D.22851 = mono_domain_get ();
    ji = mini_jit_info_table_find (D.22851, D.22850, 0B);
    if (ji != 0B) goto <D.22852>; else goto <D.22853>;
    <D.22852>:
    gsctx = mono_jit_info_get_generic_sharing_context (ji);
    if (gsctx != 0B) goto <D.22856>; else goto <D.22857>;
    <D.22856>:
    D.22858 = gsctx->var_is_vt;
    if (D.22858 != 0B) goto <D.22854>; else goto <D.22859>;
    <D.22859>:
    D.22860 = gsctx->mvar_is_vt;
    if (D.22860 != 0B) goto <D.22854>; else goto <D.22855>;
    <D.22854>:
    printf (") <gsharedvt>\n");
    return;
    <D.22855>:
    <D.22857>:
    <D.22853>:
  }
  <D.22848>:
  D.22840 = sig->param_count;
  D.22841 = (int) D.22840;
  mono_arch_get_argument_info (gsctx, sig, D.22841, arg_info);
  D.22861 = mono_method_signature (method);
  D.22862 = D.22861->ret;
  D.22863 = mono_type_is_struct (D.22862);
  if (D.22863 != 0) goto <D.22864>; else goto <D.22865>;
  <D.22864>:
  D.22866 = mono_method_signature (method);
  D.22867 = D.22866->ret;
  D.22868 = BIT_FIELD_REF <*D.22867, 8, 56>;
  D.22869 = D.22868 & 64;
  D.22870 = D.22869 != 0;
  D.22871 = (long int) D.22870;
  D.22872 = __builtin_expect (D.22871, 0);
  if (D.22872 != 0) goto <D.22873>; else goto <D.22874>;
  <D.22873>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "trace.c", 430, "!mono_method_signature (method)->ret->byref");
  <D.22874>:
  D.22875 = ebp + 8;
  D.22876 = *D.22875;
  printf ("VALUERET:%p, ", D.22876);
  <D.22865>:
  D.22877 = mono_method_signature (method);
  D.22878 = BIT_FIELD_REF <*D.22877, 8, 80>;
  D.22879 = D.22878 & 64;
  if (D.22879 != 0) goto <D.22880>; else goto <D.22881>;
  <D.22880>:
  {
    void * * this;

    D.22882 = arg_info->offset;
    D.22883 = (sizetype) D.22882;
    this = ebp + D.22883;
    D.22884 = method->klass;
    D.22885 = BIT_FIELD_REF <*D.22884, 8, 160>;
    D.22886 = D.22885 & 8;
    if (D.22886 != 0) goto <D.22887>; else goto <D.22888>;
    <D.22887>:
    D.22889 = MEM[(void * * *)this];
    printf ("value:%p, ", D.22889);
    goto <D.22890>;
    <D.22888>:
    o = MEM[(struct MonoObject * *)this];
    if (o != 0B) goto <D.22891>; else goto <D.22892>;
    <D.22891>:
    D.22893 = o->vtable;
    class = D.22893->klass;
    D.22894 = mono_defaults.string_class;
    if (D.22894 == class) goto <D.22895>; else goto <D.22896>;
    <D.22895>:
    {
      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.22897>;
    <D.22896>:
    D.22893 = o->vtable;
    D.22898 = D.22893->domain;
    D.22899 = D.22898->friendly_name;
    D.22900 = class->name;
    D.22901 = class->name_space;
    printf ("this:%p[%s.%s %s], ", o, D.22901, D.22900, D.22899);
    <D.22897>:
    goto <D.22902>;
    <D.22892>:
    printf ("this:NULL, ");
    <D.22902>:
    <D.22890>:
  }
  <D.22881>:
  i = 0;
  goto <D.22249>;
  <D.22248>:
  {
    void * * cpos;
    int size;
    struct MonoType * type;

    i.29 = (sizetype) i;
    D.22904 = i.29 + 1;
    D.22905 = D.22904 * 6;
    D.22906 = arg_info + D.22905;
    D.22907 = D.22906->offset;
    D.22908 = (sizetype) D.22907;
    cpos = ebp + D.22908;
    i.29 = (sizetype) i;
    D.22904 = i.29 + 1;
    D.22905 = D.22904 * 6;
    D.22906 = arg_info + D.22905;
    D.22909 = D.22906->size;
    size = (int) D.22909;
    D.22910 = mono_method_signature (method);
    type = D.22910->params[i];
    D.22911 = BIT_FIELD_REF <*type, 8, 56>;
    D.22912 = D.22911 & 64;
    if (D.22912 != 0) goto <D.22913>; else goto <D.22914>;
    <D.22913>:
    D.22915 = MEM[(void * * *)cpos];
    printf ("[BYREF:%p], ", D.22915);
    goto <D.22916>;
    <D.22914>:
    D.22917 = mono_type_get_underlying_type (type);
    D.22918 = D.22917->type;
    D.22919 = (int) D.22918;
    switch (D.22919) <default: <D.22247>, case 2: <D.22221>, case 3: <D.22222>, case 4: <D.22223>, case 5: <D.22224>, case 6: <D.22225>, case 7: <D.22226>, case 8: <D.22227>, case 9: <D.22228>, case 10: <D.22239>, case 11: <D.22240>, case 12: <D.22241>, case 13: <D.22242>, case 14: <D.22229>, case 15: <D.22235>, case 17: <D.22243>, case 18: <D.22232>, case 20: <D.22237>, case 24: <D.22218>, case 25: <D.22219>, case 27: <D.22236>, case 28: <D.22233>, case 29: <D.22238>>
    <D.22218>:
    <D.22219>:
    D.22915 = MEM[(void * * *)cpos];
    printf ("%p, ", D.22915);
    goto <D.22220>;
    <D.22221>:
    <D.22222>:
    <D.22223>:
    <D.22224>:
    D.22920 = MEM[(gint8 *)cpos];
    D.22921 = (int) D.22920;
    printf ("%d, ", D.22921);
    goto <D.22220>;
    <D.22225>:
    <D.22226>:
    D.22922 = MEM[(gint16 *)cpos];
    D.22923 = (int) D.22922;
    printf ("%d, ", D.22923);
    goto <D.22220>;
    <D.22227>:
    <D.22228>:
    D.22924 = MEM[(int *)cpos];
    printf ("%d, ", D.22924);
    goto <D.22220>;
    <D.22229>:
    {
      struct MonoString * s;

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

        D.22927 = MEM[(struct MonoObject *)s].vtable;
        D.22928 = D.22927->klass;
        D.22894 = mono_defaults.string_class;
        D.22929 = D.22928 != D.22894;
        D.22930 = (long int) D.22929;
        D.22931 = __builtin_expect (D.22930, 0);
        if (D.22931 != 0) goto <D.22932>; else goto <D.22933>;
        <D.22932>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "trace.c", 492, "((MonoObject *)s)->vtable->klass == mono_defaults.string_class");
        <D.22933>:
        as = string_to_utf8 (s);
        printf ("[STRING:%p:%s], ", s, as);
        monoeg_g_free (as);
      }
      goto <D.22934>;
      <D.22926>:
      printf ("[STRING:null], ");
      <D.22934>:
      goto <D.22220>;
    }
    <D.22232>:
    <D.22233>:
    o = MEM[(struct MonoObject * *)cpos];
    if (o != 0B) goto <D.22935>; else goto <D.22936>;
    <D.22935>:
    D.22893 = o->vtable;
    class = D.22893->klass;
    D.22894 = mono_defaults.string_class;
    if (D.22894 == class) goto <D.22937>; else goto <D.22938>;
    <D.22937>:
    {
      char * as;

      as = string_to_utf8 (o);
      printf ("[STRING:%p:%s], ", o, as);
      monoeg_g_free (as);
    }
    goto <D.22939>;
    <D.22938>:
    D.22940 = mono_defaults.int32_class;
    if (D.22940 == class) goto <D.22941>; else goto <D.22942>;
    <D.22941>:
    D.22943 = o + 8;
    D.22944 = *D.22943;
    printf ("[INT32:%p:%d], ", o, D.22944);
    goto <D.22945>;
    <D.22942>:
    D.22946 = mono_defaults.monotype_class;
    if (D.22946 == class) goto <D.22947>; else goto <D.22948>;
    <D.22947>:
    D.22949 = MEM[(struct MonoReflectionType *)o].type;
    D.22950 = mono_type_full_name (D.22949);
    printf ("[TYPE:%s], ", D.22950);
    goto <D.22951>;
    <D.22948>:
    D.22900 = class->name;
    D.22901 = class->name_space;
    printf ("[%s.%s:%p], ", D.22901, D.22900, o);
    <D.22951>:
    <D.22945>:
    <D.22939>:
    goto <D.22952>;
    <D.22936>:
    D.22953 = *cpos;
    printf ("%p, ", D.22953);
    <D.22952>:
    goto <D.22220>;
    <D.22235>:
    <D.22236>:
    <D.22237>:
    <D.22238>:
    D.22953 = *cpos;
    printf ("%p, ", D.22953);
    goto <D.22220>;
    <D.22239>:
    <D.22240>:
    D.22954 = MEM[(gint64 *)cpos];
    printf ("0x%016llx, ", D.22954);
    goto <D.22220>;
    <D.22241>:
    D.22955 = MEM[(float *)cpos];
    D.22956 = (double) D.22955;
    printf ("%f, ", D.22956);
    goto <D.22220>;
    <D.22242>:
    D.22957 = MEM[(double *)cpos];
    printf ("%f, ", D.22957);
    goto <D.22220>;
    <D.22243>:
    printf ("[");
    j = 0;
    goto <D.22245>;
    <D.22244>:
    j.30 = (sizetype) j;
    D.22959 = cpos + j.30;
    D.22960 = *D.22959;
    D.22961 = (int) D.22960;
    printf ("%02x,", D.22961);
    j = j + 1;
    <D.22245>:
    if (j < size) goto <D.22244>; else goto <D.22246>;
    <D.22246>:
    printf ("], ");
    goto <D.22220>;
    <D.22247>:
    printf ("XX, ");
    <D.22220>:
    <D.22916>:
  }
  i = i + 1;
  <D.22249>:
  D.22962 = mono_method_signature (method);
  D.22963 = D.22962->param_count;
  D.22964 = (int) D.22963;
  if (D.22964 > i) goto <D.22248>; else goto <D.22250>;
  <D.22250>:
  printf (")\n");
  stdout.31 = stdout;
  fflush (stdout.31);
}


indent (int diff)
{
  int indent_level.32;
  int indent_level.33;
  long long unsigned int start_time.34;
  long long int D.22974;
  long long unsigned int start_time.35;
  double D.22976;
  unsigned int D.22977;
  void * D.22978;

  if (diff < 0) goto <D.22967>; else goto <D.22968>;
  <D.22967>:
  indent_level.32 = indent_level;
  indent_level.33 = indent_level.32 + diff;
  indent_level = indent_level.33;
  <D.22968>:
  start_time.34 = start_time;
  if (start_time.34 == 0) goto <D.22972>; else goto <D.22973>;
  <D.22972>:
  D.22974 = mono_100ns_ticks ();
  start_time.35 = (long long unsigned int) D.22974;
  start_time = start_time.35;
  <D.22973>:
  indent_level.32 = indent_level;
  D.22976 = seconds_since_start ();
  D.22977 = GetCurrentThreadId ();
  D.22978 = (void *) D.22977;
  printf ("[%p: %.5f %d] ", D.22978, D.22976, indent_level.32);
  if (diff > 0) goto <D.22979>; else goto <D.22980>;
  <D.22979>:
  indent_level.32 = indent_level;
  indent_level.33 = indent_level.32 + diff;
  indent_level = indent_level.33;
  <D.22980>:
}


seconds_since_start ()
{
  long long int D.22981;
  long long unsigned int D.22982;
  long long unsigned int start_time.36;
  double D.22984;
  double D.22985;
  guint64 diff;

  D.22981 = mono_100ns_ticks ();
  D.22982 = (long long unsigned int) D.22981;
  start_time.36 = start_time;
  diff = D.22982 - start_time.36;
  D.22985 = (double) diff;
  D.22984 = D.22985 / 1.0e+7;
  return D.22984;
}


string_to_utf8 (struct MonoString * s)
{
  _Bool D.22987;
  long int D.22988;
  long int D.22989;
  int D.22992;
  char * D.22995;
  mono_unichar2 * D.22996;
  struct GError * error.37;
  char * as;
  struct GError * error;

  try
    {
      error = 0B;
      D.22987 = s == 0B;
      D.22988 = (long int) D.22987;
      D.22989 = __builtin_expect (D.22988, 0);
      if (D.22989 != 0) goto <D.22990>; else goto <D.22991>;
      <D.22990>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "trace.c", 355, "s");
      <D.22991>:
      D.22992 = s->length;
      if (D.22992 == 0) goto <D.22993>; else goto <D.22994>;
      <D.22993>:
      D.22995 = monoeg_strdup ("");
      return D.22995;
      <D.22994>:
      D.22992 = s->length;
      D.22996 = mono_string_chars (s);
      as = monoeg_g_utf16_to_utf8 (D.22996, D.22992, 0B, 0B, &error);
      error.37 = error;
      if (error.37 != 0B) goto <D.22998>; else goto <D.22999>;
      <D.22998>:
      error.37 = error;
      monoeg_g_error_free (error.37);
      D.22995 = monoeg_strdup ("<INVALID UTF8>");
      return D.22995;
      <D.22999>:
      D.22995 = as;
      return D.22995;
    }
  finally
    {
      error = {CLOBBER};
    }
}


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

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


mono_trace_leave_method (struct MonoMethod * method)
{
  int D.23004;
  unsigned char D.23007;
  unsigned char D.23008;
  void * D.23011;
  void * D.23012;
  struct MonoDomain * D.23013;
  gboolean * D.23020;
  gboolean * D.23022;
  struct MonoMethodSignature * D.23023;
  unsigned char D.23024;
  int D.23025;
  char * ap.38;
  char * ap.39;
  char * ap.40;
  char * ap.41;
  char * ap.42;
  char * ap.43;
  struct MonoVTable * D.23037;
  struct MonoClass * D.23038;
  struct MonoClass * D.23039;
  _Bool D.23040;
  long int D.23041;
  long int D.23042;
  char * ap.44;
  char * ap.45;
  struct MonoVTable * D.23050;
  struct MonoClass * D.23051;
  struct MonoClass * D.23052;
  guint8 * D.23055;
  unsigned char D.23056;
  int D.23057;
  struct MonoClass * D.23059;
  gint32 * D.23062;
  int D.23063;
  struct MonoClass * D.23065;
  gint64 * D.23068;
  long long int D.23069;
  const char * D.23071;
  const char * D.23072;
  char * ap.46;
  char * ap.47;
  char * ap.48;
  char * ap.49;
  char * ap.50;
  char * ap.51;
  char * ap.52;
  char * ap.53;
  struct MonoClass * D.23082;
  unsigned char D.23083;
  unsigned char D.23084;
  char * ap.54;
  char * ap.55;
  sizetype j.56;
  guint8 * D.23090;
  unsigned char D.23091;
  int D.23092;
  _Bool D.23093;
  _Bool D.23094;
  _Bool D.23095;
  struct MonoMethodSignature * D.23096;
  struct MonoType * D.23097;
  unsigned char D.23098;
  int D.23099;
  struct _IO_FILE * stdout.57;
  struct MonoType * type;
  char * fname;
  char * ap;
  struct MonoGenericSharingContext * gsctx;
  void handle_enum = <<< error >>>;

  try
    {
      D.23004 = trace_spec.enabled;
      if (D.23004 == 0) goto <D.23005>; else goto <D.23006>;
      <D.23005>:
      return;
      <D.23006>:
      __builtin_va_start (&ap, 0);
      fname = mono_method_full_name (method, 1);
      indent (-1);
      printf ("LEAVE: %s", fname);
      monoeg_g_free (fname);
      D.23007 = BIT_FIELD_REF <*method, 8, 168>;
      D.23008 = D.23007 & 16;
      if (D.23008 != 0) goto <D.23009>; else goto <D.23010>;
      <D.23009>:
      {
        struct MonoJitInfo * ji;

        D.23011 = __builtin_return_address (0);
        D.23012 = __builtin_extract_return_addr (D.23011);
        D.23013 = mono_domain_get ();
        ji = mini_jit_info_table_find (D.23013, D.23012, 0B);
        if (ji != 0B) goto <D.23014>; else goto <D.23015>;
        <D.23014>:
        gsctx = mono_jit_info_get_generic_sharing_context (ji);
        if (gsctx != 0B) goto <D.23018>; else goto <D.23019>;
        <D.23018>:
        D.23020 = gsctx->var_is_vt;
        if (D.23020 != 0B) goto <D.23016>; else goto <D.23021>;
        <D.23021>:
        D.23022 = gsctx->mvar_is_vt;
        if (D.23022 != 0B) goto <D.23016>; else goto <D.23017>;
        <D.23016>:
        printf (") <gsharedvt>\n");
        return;
        <D.23017>:
        <D.23019>:
        <D.23015>:
      }
      <D.23010>:
      D.23023 = mono_method_signature (method);
      type = D.23023->ret;
      handle_enum:
      D.23024 = type->type;
      D.23025 = (int) D.23024;
      switch (D.23025) <default: <D.22300>, case 1: <D.22260>, case 2: <D.22262>, case 3: <D.22264>, case 4: <D.22265>, case 5: <D.22266>, case 6: <D.22267>, case 7: <D.22268>, case 8: <D.22269>, case 9: <D.22270>, case 10: <D.22285>, case 11: <D.22287>, case 12: <D.22289>, case 13: <D.22290>, case 14: <D.22274>, case 15: <D.22280>, case 17: <D.22292>, case 18: <D.22277>, case 20: <D.22282>, case 24: <D.22271>, case 25: <D.22272>, case 27: <D.22281>, case 28: <D.22278>, case 29: <D.22283>>
      <D.22260>:
      goto <D.22261>;
      <D.22262>:
      {
        int eax;

        ap.38 = ap;
        ap.39 = ap.38 + 4;
        ap = ap.39;
        eax = MEM[(int *)ap.38];
        if (eax != 0) goto <D.23028>; else goto <D.23029>;
        <D.23028>:
        printf ("TRUE:%d", eax);
        goto <D.23030>;
        <D.23029>:
        printf ("FALSE");
        <D.23030>:
        goto <D.22261>;
      }
      <D.22264>:
      <D.22265>:
      <D.22266>:
      <D.22267>:
      <D.22268>:
      <D.22269>:
      <D.22270>:
      <D.22271>:
      <D.22272>:
      {
        int eax;

        ap.40 = ap;
        ap.41 = ap.40 + 4;
        ap = ap.41;
        eax = MEM[(int *)ap.40];
        printf ("result=%d", eax);
        goto <D.22261>;
      }
      <D.22274>:
      {
        struct MonoString * s;

        ap.42 = ap;
        ap.43 = ap.42 + 4;
        ap = ap.43;
        s = MEM[(struct MonoString * *)ap.42];
        if (s != 0B) goto <D.23035>; else goto <D.23036>;
        <D.23035>:
        {
          char * as;

          D.23037 = MEM[(struct MonoObject *)s].vtable;
          D.23038 = D.23037->klass;
          D.23039 = mono_defaults.string_class;
          D.23040 = D.23038 != D.23039;
          D.23041 = (long int) D.23040;
          D.23042 = __builtin_expect (D.23041, 0);
          if (D.23042 != 0) goto <D.23043>; else goto <D.23044>;
          <D.23043>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "trace.c", 619, "((MonoObject *)s)->vtable->klass == mono_defaults.string_class");
          <D.23044>:
          as = string_to_utf8 (s);
          printf ("[STRING:%p:%s]", s, as);
          monoeg_g_free (as);
        }
        goto <D.23045>;
        <D.23036>:
        printf ("[STRING:null], ");
        <D.23045>:
        goto <D.22261>;
      }
      <D.22277>:
      <D.22278>:
      {
        struct MonoObject * o;

        ap.44 = ap;
        ap.45 = ap.44 + 4;
        ap = ap.45;
        o = MEM[(struct MonoObject * *)ap.44];
        if (o != 0B) goto <D.23048>; else goto <D.23049>;
        <D.23048>:
        D.23050 = o->vtable;
        D.23051 = D.23050->klass;
        D.23052 = mono_defaults.boolean_class;
        if (D.23051 == D.23052) goto <D.23053>; else goto <D.23054>;
        <D.23053>:
        D.23055 = o + 8;
        D.23056 = *D.23055;
        D.23057 = (int) D.23056;
        printf ("[BOOLEAN:%p:%d]", o, D.23057);
        goto <D.23058>;
        <D.23054>:
        D.23050 = o->vtable;
        D.23051 = D.23050->klass;
        D.23059 = mono_defaults.int32_class;
        if (D.23051 == D.23059) goto <D.23060>; else goto <D.23061>;
        <D.23060>:
        D.23062 = o + 8;
        D.23063 = *D.23062;
        printf ("[INT32:%p:%d]", o, D.23063);
        goto <D.23064>;
        <D.23061>:
        D.23050 = o->vtable;
        D.23051 = D.23050->klass;
        D.23065 = mono_defaults.int64_class;
        if (D.23051 == D.23065) goto <D.23066>; else goto <D.23067>;
        <D.23066>:
        D.23068 = o + 8;
        D.23069 = *D.23068;
        printf ("[INT64:%p:%lld]", o, D.23069);
        goto <D.23070>;
        <D.23067>:
        D.23050 = o->vtable;
        D.23051 = D.23050->klass;
        D.23071 = D.23051->name;
        D.23050 = o->vtable;
        D.23051 = D.23050->klass;
        D.23072 = D.23051->name_space;
        printf ("[%s.%s:%p]", D.23072, D.23071, o);
        <D.23070>:
        <D.23064>:
        <D.23058>:
        goto <D.23073>;
        <D.23049>:
        printf ("[OBJECT:%p]", o);
        <D.23073>:
        goto <D.22261>;
      }
      <D.22280>:
      <D.22281>:
      <D.22282>:
      <D.22283>:
      {
        void * p;

        ap.46 = ap;
        ap.47 = ap.46 + 4;
        ap = ap.47;
        p = MEM[(void * *)ap.46];
        printf ("result=%p", p);
        goto <D.22261>;
      }
      <D.22285>:
      {
        gint64 l;

        ap.48 = ap;
        ap.49 = ap.48 + 8;
        ap = ap.49;
        l = MEM[(gint64 *)ap.48];
        printf ("lresult=0x%16llx", l);
        goto <D.22261>;
      }
      <D.22287>:
      {
        gint64 l;

        ap.50 = ap;
        ap.51 = ap.50 + 8;
        ap = ap.51;
        l = MEM[(gint64 *)ap.50];
        printf ("lresult=0x%16llx", l);
        goto <D.22261>;
      }
      <D.22289>:
      <D.22290>:
      {
        double f;

        ap.52 = ap;
        ap.53 = ap.52 + 8;
        ap = ap.53;
        f = MEM[(double *)ap.52];
        printf ("FP=%f", f);
        goto <D.22261>;
      }
      <D.22292>:
      D.23082 = type->data.klass;
      D.23083 = BIT_FIELD_REF <*D.23082, 8, 160>;
      D.23084 = D.23083 & 16;
      if (D.23084 != 0) goto <D.23085>; else goto <D.23086>;
      <D.23085>:
      D.23082 = type->data.klass;
      type = mono_class_enum_basetype (D.23082);
      goto handle_enum;
      <D.23086>:
      {
        guint8 * p;
        int j;
        int size;
        int align;

        try
          {
            ap.54 = ap;
            ap.55 = ap.54 + 4;
            ap = ap.55;
            p = MEM[(void * *)ap.54];
            size = mono_type_size (type, &align);
            printf ("[");
            j = 0;
            goto <D.22298>;
            <D.22297>:
            j.56 = (sizetype) j;
            D.23090 = p + j.56;
            D.23091 = *D.23090;
            D.23092 = (int) D.23091;
            printf ("%02x,", D.23092);
            j = j + 1;
            <D.22298>:
            D.23093 = p != 0B;
            D.23094 = j < size;
            D.23095 = D.23093 & D.23094;
            if (D.23095 != 0) goto <D.22297>; else goto <D.22299>;
            <D.22299>:
            printf ("]");
          }
        finally
          {
            align = {CLOBBER};
          }
      }
      goto <D.22261>;
      <D.22300>:
      D.23096 = mono_method_signature (method);
      D.23097 = D.23096->ret;
      D.23098 = D.23097->type;
      D.23099 = (int) D.23098;
      printf ("(unknown return type %x)", D.23099);
      <D.22261>:
      printf ("\n");
      stdout.57 = stdout;
      fflush (stdout.57);
    }
  finally
    {
      ap = {CLOBBER};
    }
}


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


mono_trace_is_enabled ()
{
  gboolean D.23105;

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