__attribute__((visibility ("hidden")))
mono_trace_eval_exception (struct MonoClass * klass)
{
  gboolean D.22550;
  struct MonoTraceOperation * D.22551;
  long unsigned int D.22552;
  long unsigned int D.22553;
  <unnamed type> D.22554;
  void * D.22557;
  unsigned char D.22558;
  void * D.22560;
  int D.22561;
  const char * D.22566;
  int D.22567;
  const char * D.22568;
  int D.22569;
  int D.22572;
  int D.22580;
  int include;
  int i;

  include = 0;
  if (klass == 0B) goto <D.22548>; else goto <D.22549>;
  <D.22548>:
  D.22550 = 0;
  return D.22550;
  <D.22549>:
  i = 0;
  goto <D.22348>;
  <D.22347>:
  {
    struct MonoTraceOperation * op;
    int inc;

    D.22551 = trace_spec.ops;
    D.22552 = (long unsigned int) i;
    D.22553 = D.22552 * 24;
    op = D.22551 + D.22553;
    inc = 0;
    D.22554 = op->op;
    switch (D.22554) <default: <D.22346>, case 6: <D.22344>>
    <D.22344>:
    D.22557 = op->data;
    D.22558 = MEM[(const unsigned char * {ref-all})D.22557];
    if (D.22558 == 0) goto <D.22559>; else goto <D.22555>;
    <D.22559>:
    D.22560 = op->data2;
    D.22561 = strcmp ("all", D.22560);
    if (D.22561 == 0) goto <D.22562>; else goto <D.22555>;
    <D.22562>:
    inc = 1;
    goto <D.22556>;
    <D.22555>:
    D.22557 = op->data;
    D.22558 = MEM[(const unsigned char * {ref-all})D.22557];
    if (D.22558 == 0) goto <D.22563>; else goto <D.22565>;
    <D.22565>:
    D.22566 = klass->name_space;
    D.22557 = op->data;
    D.22567 = strcmp (D.22566, D.22557);
    if (D.22567 == 0) goto <D.22563>; else goto <D.22564>;
    <D.22563>:
    D.22568 = klass->name;
    D.22560 = op->data2;
    D.22569 = strcmp (D.22568, D.22560);
    if (D.22569 == 0) goto <D.22570>; else goto <D.22571>;
    <D.22570>:
    inc = 1;
    <D.22571>:
    <D.22564>:
    <D.22556>:
    goto <D.22345>;
    <D.22346>:
    goto <D.22345>;
    <D.22345>:
    D.22572 = op->exclude;
    if (D.22572 != 0) goto <D.22573>; else goto <D.22574>;
    <D.22573>:
    if (inc != 0) goto <D.22575>; else goto <D.22576>;
    <D.22575>:
    include = 0;
    <D.22576>:
    goto <D.22577>;
    <D.22574>:
    if (inc != 0) goto <D.22578>; else goto <D.22579>;
    <D.22578>:
    include = 1;
    <D.22579>:
    <D.22577>:
  }
  i = i + 1;
  <D.22348>:
  D.22580 = trace_spec.len;
  if (D.22580 > i) goto <D.22347>; else goto <D.22349>;
  <D.22349>:
  D.22550 = include;
  return D.22550;
}


__attribute__((__gnu_inline__, nothrow, leaf, pure))
strcmp (const char * __s1, const char * __s2)
{
  int iftmp.0;
  int iftmp.1;
  int D.22591;
  char * __p1;
  char * __p2;
  int __ret;

  __p1 = __s1;
  __p2 = __s2;
  __asm__ __volatile__("   slr   0,0
0: clst  %1,%2
   jo    0b
   ipm   %0
   srl   %0,28" : "=d" __ret, "=&a" __p1, "=&a" __p2 : "1" __p1, "2" __p2 : "0", "memory", "cc");
  if (__ret != 0) goto <D.22584>; else goto <D.22585>;
  <D.22584>:
  if (__ret == 1) goto <D.22587>; else goto <D.22588>;
  <D.22587>:
  iftmp.1 = -1;
  goto <D.22589>;
  <D.22588>:
  iftmp.1 = 1;
  <D.22589>:
  iftmp.0 = iftmp.1;
  goto <D.22590>;
  <D.22585>:
  iftmp.0 = 0;
  <D.22590>:
  __ret = iftmp.0;
  D.22591 = __ret;
  return D.22591;
}


__attribute__((visibility ("hidden")))
mono_trace_eval (struct MonoMethod * method)
{
  struct MonoTraceOperation * D.22593;
  long unsigned int D.22594;
  long unsigned int D.22595;
  <unnamed type> D.22596;
  struct MonoAssembly * D.22597;
  struct MonoClass * D.22600;
  struct MonoImage * D.22601;
  struct MonoImage * D.22602;
  long unsigned int D.22607;
  long unsigned int D.22608;
  void * D.22610;
  int D.22611;
  const char * D.22614;
  int D.22615;
  const char * D.22618;
  void * D.22619;
  int D.22620;
  const char * D.22623;
  int D.22624;
  int D.22627;
  int D.22631;
  int D.22639;
  gboolean D.22640;
  int include;
  int i;

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

    D.22593 = trace_spec.ops;
    D.22594 = (long unsigned int) i;
    D.22595 = D.22594 * 24;
    op = D.22593 + D.22595;
    inc = 0;
    D.22596 = op->op;
    switch (D.22596) <default: <D.22630>, case 0: <D.22357>, case 1: <D.22359>, case 2: <D.22361>, case 3: <D.22363>, case 4: <D.22362>, case 5: <D.22364>, case 6: <D.22365>, case 7: <D.22360>>
    <D.22357>:
    inc = 1;
    goto <D.22358>;
    <D.22359>:
    D.22597 = trace_spec.assembly;
    if (D.22597 != 0B) goto <D.22598>; else goto <D.22599>;
    <D.22598>:
    D.22600 = method->klass;
    D.22601 = D.22600->image;
    D.22597 = trace_spec.assembly;
    D.22602 = mono_assembly_get_image (D.22597);
    if (D.22601 == D.22602) goto <D.22603>; else goto <D.22604>;
    <D.22603>:
    inc = 1;
    <D.22604>:
    <D.22599>:
    goto <D.22358>;
    <D.22360>:
    D.22607 = BIT_FIELD_REF <*method, 64, 256>;
    D.22608 = D.22607 & 4467570830351532032;
    if (D.22608 == 720575940379279360) goto <D.22605>; else goto <D.22609>;
    <D.22609>:
    D.22607 = BIT_FIELD_REF <*method, 64, 256>;
    D.22608 = D.22607 & 4467570830351532032;
    if (D.22608 == 864691128455135232) goto <D.22605>; else goto <D.22606>;
    <D.22605>:
    inc = 1;
    <D.22606>:
    goto <D.22358>;
    <D.22361>:
    D.22610 = op->data;
    D.22611 = mono_method_desc_full_match (D.22610, method);
    if (D.22611 != 0) goto <D.22612>; else goto <D.22613>;
    <D.22612>:
    inc = 1;
    <D.22613>:
    goto <D.22358>;
    <D.22362>:
    D.22600 = method->klass;
    D.22614 = D.22600->name_space;
    D.22610 = op->data;
    D.22615 = strcmp (D.22614, D.22610);
    if (D.22615 == 0) goto <D.22616>; else goto <D.22617>;
    <D.22616>:
    D.22600 = method->klass;
    D.22618 = D.22600->name;
    D.22619 = op->data2;
    D.22620 = strcmp (D.22618, D.22619);
    if (D.22620 == 0) goto <D.22621>; else goto <D.22622>;
    <D.22621>:
    inc = 1;
    <D.22622>:
    <D.22617>:
    goto <D.22358>;
    <D.22363>:
    D.22600 = method->klass;
    D.22601 = D.22600->image;
    D.22623 = mono_image_get_name (D.22601);
    D.22610 = op->data;
    D.22624 = strcmp (D.22623, D.22610);
    if (D.22624 == 0) goto <D.22625>; else goto <D.22626>;
    <D.22625>:
    inc = 1;
    <D.22626>:
    goto <D.22358>;
    <D.22364>:
    D.22600 = method->klass;
    D.22614 = D.22600->name_space;
    D.22610 = op->data;
    D.22627 = strcmp (D.22614, D.22610);
    if (D.22627 == 0) goto <D.22628>; else goto <D.22629>;
    <D.22628>:
    inc = 1;
    <D.22629>:
    <D.22365>:
    goto <D.22358>;
    <D.22630>:
    <D.22358>:
    D.22631 = op->exclude;
    if (D.22631 != 0) goto <D.22632>; else goto <D.22633>;
    <D.22632>:
    if (inc != 0) goto <D.22634>; else goto <D.22635>;
    <D.22634>:
    include = 0;
    <D.22635>:
    goto <D.22636>;
    <D.22633>:
    if (inc != 0) goto <D.22637>; else goto <D.22638>;
    <D.22637>:
    include = 1;
    <D.22638>:
    <D.22636>:
  }
  i = i + 1;
  <D.22367>:
  D.22639 = trace_spec.len;
  if (D.22639 > i) goto <D.22366>; else goto <D.22368>;
  <D.22368>:
  D.22640 = include;
  return D.22640;
}


__attribute__((visibility ("hidden")))
mono_trace_parse_options (const char * options)
{
  char D.22642;
  void * D.22645;
  struct MonoTraceOperation * D.22646;
  struct MonoTraceSpec * D.22647;
  long unsigned int D.22650;
  long unsigned int D.22651;
  void * D.22652;
  int last_used.2;
  char * p;
  int size;
  int last_used;
  int token;

  try
    {
      p = options;
      size = 1;
      trace_spec.enabled = 1;
      D.22642 = *p;
      if (D.22642 == 0) goto <D.22643>; else goto <D.22644>;
      <D.22643>:
      trace_spec.len = 1;
      D.22645 = monoeg_malloc0 (24);
      trace_spec.ops = D.22645;
      D.22646 = trace_spec.ops;
      D.22646->op = 0;
      D.22647 = &trace_spec;
      return D.22647;
      <D.22644>:
      p = options;
      goto <D.22418>;
      <D.22417>:
      D.22642 = *p;
      if (D.22642 == 44) goto <D.22648>; else goto <D.22649>;
      <D.22648>:
      size = size + 1;
      <D.22649>:
      p = p + 1;
      <D.22418>:
      D.22642 = *p;
      if (D.22642 != 0) goto <D.22417>; else goto <D.22419>;
      <D.22419>:
      D.22650 = (long unsigned int) size;
      D.22651 = D.22650 * 24;
      D.22652 = monoeg_malloc0 (D.22651);
      trace_spec.ops = D.22652;
      input = options;
      last_used = 0;
      goto <D.22420>;
      <D.22421>:
      if (token == 12) goto <D.22653>; else goto <D.22654>;
      <D.22653>:
      D.22647 = 0B;
      return D.22647;
      <D.22654>:
      if (token == 10) goto <D.22655>; else goto <D.22656>;
      <D.22655>:
      // predicted unlikely by continue predictor.
      goto <D.22420>;
      <D.22656>:
      <D.22420>:
      token = get_spec (&last_used);
      if (token != 11) goto <D.22421>; else goto <D.22422>;
      <D.22422>:
      last_used.2 = last_used;
      trace_spec.len = last_used.2;
      cleanup ();
      D.22647 = &trace_spec;
      return D.22647;
    }
  finally
    {
      last_used = {CLOBBER};
    }
}


get_spec (int * last)
{
  struct _IO_FILE * stderr.3;
  int D.22665;
  struct MonoTraceOperation * D.22668;
  int D.22669;
  long unsigned int D.22670;
  long unsigned int D.22671;
  sizetype D.22672;
  struct MonoTraceOperation * D.22673;
  unsigned int token.4;
  unsigned int D.22675;
  char * value.5;
  struct MonoTraceOperation * D.22683;
  gchar * D.22696;
  char * p.6;
  gchar * D.22705;
  gchar * D.22706;
  gchar * D.22708;
  gchar * D.22709;
  MonoTraceOpcode iftmp.7;
  gchar * D.22716;
  int D.22721;
  int token;

  token = get_token ();
  if (token == 8) goto <D.22660>; else goto <D.22661>;
  <D.22660>:
  token = get_spec (last);
  if (token == 8) goto <D.22662>; else goto <D.22663>;
  <D.22662>:
  stderr.3 = stderr;
  fprintf (stderr.3, "Expecting an expression");
  D.22665 = 12;
  return D.22665;
  <D.22663>:
  if (token == 12) goto <D.22666>; else goto <D.22667>;
  <D.22666>:
  D.22665 = token;
  return D.22665;
  <D.22667>:
  D.22668 = trace_spec.ops;
  D.22669 = *last;
  D.22670 = (long unsigned int) D.22669;
  D.22671 = D.22670 * 24;
  D.22672 = D.22671 + 18446744073709551592;
  D.22673 = D.22668 + D.22672;
  D.22673->exclude = 1;
  D.22665 = 10;
  return D.22665;
  <D.22661>:
  token.4 = (unsigned int) token;
  D.22675 = token.4 + 4294967286;
  if (D.22675 <= 2) goto <D.22676>; else goto <D.22677>;
  <D.22676>:
  D.22665 = token;
  return D.22665;
  <D.22677>:
  if (token == 0) goto <D.22678>; else goto <D.22679>;
  <D.22678>:
  {
    struct MonoMethodDesc * desc;

    value.5 = value;
    desc = mono_method_desc_new (value.5, 1);
    if (desc == 0B) goto <D.22681>; else goto <D.22682>;
    <D.22681>:
    stderr.3 = stderr;
    value.5 = value;
    fprintf (stderr.3, "Invalid method name: %s\n", value.5);
    D.22665 = 12;
    return D.22665;
    <D.22682>:
    D.22668 = trace_spec.ops;
    D.22669 = *last;
    D.22670 = (long unsigned int) D.22669;
    D.22671 = D.22670 * 24;
    D.22683 = D.22668 + D.22671;
    D.22683->op = 2;
    D.22668 = trace_spec.ops;
    D.22669 = *last;
    D.22670 = (long unsigned int) D.22669;
    D.22671 = D.22670 * 24;
    D.22683 = D.22668 + D.22671;
    D.22683->data = desc;
  }
  goto <D.22684>;
  <D.22679>:
  if (token == 2) goto <D.22685>; else goto <D.22686>;
  <D.22685>:
  D.22668 = trace_spec.ops;
  D.22669 = *last;
  D.22670 = (long unsigned int) D.22669;
  D.22671 = D.22670 * 24;
  D.22683 = D.22668 + D.22671;
  D.22683->op = 0;
  goto <D.22687>;
  <D.22686>:
  if (token == 3) goto <D.22688>; else goto <D.22689>;
  <D.22688>:
  D.22668 = trace_spec.ops;
  D.22669 = *last;
  D.22670 = (long unsigned int) D.22669;
  D.22671 = D.22670 * 24;
  D.22683 = D.22668 + D.22671;
  D.22683->op = 1;
  goto <D.22690>;
  <D.22689>:
  if (token == 6) goto <D.22691>; else goto <D.22692>;
  <D.22691>:
  D.22668 = trace_spec.ops;
  D.22669 = *last;
  D.22670 = (long unsigned int) D.22669;
  D.22671 = D.22670 * 24;
  D.22683 = D.22668 + D.22671;
  D.22683->op = 7;
  goto <D.22693>;
  <D.22692>:
  if (token == 5) goto <D.22694>; else goto <D.22695>;
  <D.22694>:
  D.22668 = trace_spec.ops;
  D.22669 = *last;
  D.22670 = (long unsigned int) D.22669;
  D.22671 = D.22670 * 24;
  D.22683 = D.22668 + D.22671;
  D.22683->op = 5;
  D.22668 = trace_spec.ops;
  D.22669 = *last;
  D.22670 = (long unsigned int) D.22669;
  D.22671 = D.22670 * 24;
  D.22683 = D.22668 + D.22671;
  value.5 = value;
  D.22696 = monoeg_strdup (value.5);
  D.22683->data = D.22696;
  goto <D.22697>;
  <D.22695>:
  if (token == 1) goto <D.22698>; else goto <D.22701>;
  <D.22701>:
  if (token == 4) goto <D.22698>; else goto <D.22699>;
  <D.22698>:
  {
    char * p;

    value.5 = value;
    p = strrchr (value.5, 46);
    if (p != 0B) goto <D.22702>; else goto <D.22703>;
    <D.22702>:
    p.6 = p;
    p = p.6 + 1;
    *p.6 = 0;
    D.22668 = trace_spec.ops;
    D.22669 = *last;
    D.22670 = (long unsigned int) D.22669;
    D.22671 = D.22670 * 24;
    D.22683 = D.22668 + D.22671;
    value.5 = value;
    D.22705 = monoeg_strdup (value.5);
    D.22683->data = D.22705;
    D.22668 = trace_spec.ops;
    D.22669 = *last;
    D.22670 = (long unsigned int) D.22669;
    D.22671 = D.22670 * 24;
    D.22683 = D.22668 + D.22671;
    D.22706 = monoeg_strdup (p);
    D.22683->data2 = D.22706;
    goto <D.22707>;
    <D.22703>:
    D.22668 = trace_spec.ops;
    D.22669 = *last;
    D.22670 = (long unsigned int) D.22669;
    D.22671 = D.22670 * 24;
    D.22683 = D.22668 + D.22671;
    D.22708 = monoeg_strdup ("");
    D.22683->data = D.22708;
    D.22668 = trace_spec.ops;
    D.22669 = *last;
    D.22670 = (long unsigned int) D.22669;
    D.22671 = D.22670 * 24;
    D.22683 = D.22668 + D.22671;
    value.5 = value;
    D.22709 = monoeg_strdup (value.5);
    D.22683->data2 = D.22709;
    <D.22707>:
    D.22668 = trace_spec.ops;
    D.22669 = *last;
    D.22670 = (long unsigned int) D.22669;
    D.22671 = D.22670 * 24;
    D.22683 = D.22668 + D.22671;
    if (token == 1) goto <D.22711>; else goto <D.22712>;
    <D.22711>:
    iftmp.7 = 4;
    goto <D.22713>;
    <D.22712>:
    iftmp.7 = 6;
    <D.22713>:
    D.22683->op = iftmp.7;
  }
  goto <D.22700>;
  <D.22699>:
  if (token == 7) goto <D.22714>; else goto <D.22715>;
  <D.22714>:
  D.22668 = trace_spec.ops;
  D.22669 = *last;
  D.22670 = (long unsigned int) D.22669;
  D.22671 = D.22670 * 24;
  D.22683 = D.22668 + D.22671;
  D.22683->op = 3;
  D.22668 = trace_spec.ops;
  D.22669 = *last;
  D.22670 = (long unsigned int) D.22669;
  D.22671 = D.22670 * 24;
  D.22683 = D.22668 + D.22671;
  value.5 = value;
  D.22716 = monoeg_strdup (value.5);
  D.22683->data = D.22716;
  goto <D.22717>;
  <D.22715>:
  if (token == 9) goto <D.22718>; else goto <D.22719>;
  <D.22718>:
  trace_spec.enabled = 0;
  goto <D.22720>;
  <D.22719>:
  stderr.3 = stderr;
  fprintf (stderr.3, "Syntax error in trace option specification\n");
  D.22665 = 12;
  return D.22665;
  <D.22720>:
  <D.22717>:
  <D.22700>:
  <D.22697>:
  <D.22693>:
  <D.22690>:
  <D.22687>:
  <D.22684>:
  D.22669 = *last;
  D.22721 = D.22669 + 1;
  *last = D.22721;
  D.22665 = 10;
  return D.22665;
}


get_token ()
{
  char * input.8;
  char * D.22724;
  char D.22725;
  int D.22728;
  char D.22731;
  char * D.22734;
  int D.22749;
  char * value.9;
  int D.22753;
  int D.22756;
  int D.22759;
  int D.22762;
  struct _IO_FILE * stderr.10;

  goto <D.22399>;
  <D.22398>:
  input.8 = input;
  D.22724 = input.8 + 1;
  input = D.22724;
  <D.22399>:
  input.8 = input;
  D.22725 = *input.8;
  if (D.22725 == 43) goto <D.22398>; else goto <D.22400>;
  <D.22400>:
  input.8 = input;
  D.22725 = *input.8;
  if (D.22725 == 0) goto <D.22726>; else goto <D.22727>;
  <D.22726>:
  D.22728 = 11;
  return D.22728;
  <D.22727>:
  input.8 = input;
  D.22725 = *input.8;
  if (D.22725 == 77) goto <D.22729>; else goto <D.22730>;
  <D.22729>:
  input.8 = input;
  D.22724 = input.8 + 1;
  D.22731 = *D.22724;
  if (D.22731 == 58) goto <D.22732>; else goto <D.22733>;
  <D.22732>:
  input.8 = input;
  D.22734 = input.8 + 2;
  input = D.22734;
  get_string ();
  D.22728 = 0;
  return D.22728;
  <D.22733>:
  <D.22730>:
  input.8 = input;
  D.22725 = *input.8;
  if (D.22725 == 78) goto <D.22735>; else goto <D.22736>;
  <D.22735>:
  input.8 = input;
  D.22724 = input.8 + 1;
  D.22731 = *D.22724;
  if (D.22731 == 58) goto <D.22737>; else goto <D.22738>;
  <D.22737>:
  input.8 = input;
  D.22734 = input.8 + 2;
  input = D.22734;
  get_string ();
  D.22728 = 5;
  return D.22728;
  <D.22738>:
  <D.22736>:
  input.8 = input;
  D.22725 = *input.8;
  if (D.22725 == 84) goto <D.22739>; else goto <D.22740>;
  <D.22739>:
  input.8 = input;
  D.22724 = input.8 + 1;
  D.22731 = *D.22724;
  if (D.22731 == 58) goto <D.22741>; else goto <D.22742>;
  <D.22741>:
  input.8 = input;
  D.22734 = input.8 + 2;
  input = D.22734;
  get_string ();
  D.22728 = 1;
  return D.22728;
  <D.22742>:
  <D.22740>:
  input.8 = input;
  D.22725 = *input.8;
  if (D.22725 == 69) goto <D.22743>; else goto <D.22744>;
  <D.22743>:
  input.8 = input;
  D.22724 = input.8 + 1;
  D.22731 = *D.22724;
  if (D.22731 == 58) goto <D.22745>; else goto <D.22746>;
  <D.22745>:
  input.8 = input;
  D.22734 = input.8 + 2;
  input = D.22734;
  get_string ();
  D.22728 = 4;
  return D.22728;
  <D.22746>:
  <D.22744>:
  input.8 = input;
  D.22725 = *input.8;
  if (D.22725 == 45) goto <D.22747>; else goto <D.22748>;
  <D.22747>:
  input.8 = input;
  D.22724 = input.8 + 1;
  input = D.22724;
  D.22728 = 8;
  return D.22728;
  <D.22748>:
  input.8 = input;
  D.22725 = *input.8;
  D.22749 = is_filenamechar (D.22725);
  if (D.22749 != 0) goto <D.22750>; else goto <D.22751>;
  <D.22750>:
  get_string ();
  value.9 = value;
  D.22753 = strcmp (value.9, "all");
  if (D.22753 == 0) goto <D.22754>; else goto <D.22755>;
  <D.22754>:
  D.22728 = 2;
  return D.22728;
  <D.22755>:
  value.9 = value;
  D.22756 = strcmp (value.9, "program");
  if (D.22756 == 0) goto <D.22757>; else goto <D.22758>;
  <D.22757>:
  D.22728 = 3;
  return D.22728;
  <D.22758>:
  value.9 = value;
  D.22759 = strcmp (value.9, "wrapper");
  if (D.22759 == 0) goto <D.22760>; else goto <D.22761>;
  <D.22760>:
  D.22728 = 6;
  return D.22728;
  <D.22761>:
  value.9 = value;
  D.22762 = strcmp (value.9, "disabled");
  if (D.22762 == 0) goto <D.22763>; else goto <D.22764>;
  <D.22763>:
  D.22728 = 9;
  return D.22728;
  <D.22764>:
  D.22728 = 7;
  return D.22728;
  <D.22751>:
  input.8 = input;
  D.22725 = *input.8;
  if (D.22725 == 44) goto <D.22765>; else goto <D.22766>;
  <D.22765>:
  input.8 = input;
  D.22724 = input.8 + 1;
  input = D.22724;
  D.22728 = 10;
  return D.22728;
  <D.22766>:
  stderr.10 = stderr;
  input.8 = input;
  fprintf (stderr.10, "Syntax error at or around \'%s\'\n", input.8);
  D.22728 = 12;
  return D.22728;
}


is_filenamechar (char p)
{
  char D.22769;
  int D.22772;
  char D.22773;
  char D.22776;

  D.22769 = p + 191;
  if (D.22769 <= 25) goto <D.22770>; else goto <D.22771>;
  <D.22770>:
  D.22772 = 1;
  return D.22772;
  <D.22771>:
  D.22773 = p + 159;
  if (D.22773 <= 25) goto <D.22774>; else goto <D.22775>;
  <D.22774>:
  D.22772 = 1;
  return D.22772;
  <D.22775>:
  D.22776 = p + 208;
  if (D.22776 <= 9) goto <D.22777>; else goto <D.22778>;
  <D.22777>:
  D.22772 = 1;
  return D.22772;
  <D.22778>:
  if (p == 46) goto <D.22779>; else goto <D.22781>;
  <D.22781>:
  if (p == 58) goto <D.22779>; else goto <D.22782>;
  <D.22782>:
  if (p == 95) goto <D.22779>; else goto <D.22783>;
  <D.22783>:
  if (p == 45) goto <D.22779>; else goto <D.22780>;
  <D.22779>:
  D.22772 = 1;
  return D.22772;
  <D.22780>:
  D.22772 = 0;
  return D.22772;
}


get_string ()
{
  char * input.11;
  char * D.22786;
  char D.22787;
  int D.22788;
  char * value.12;
  long int input.13;
  long int start.14;
  long int D.22794;
  long int D.22795;
  long unsigned int D.22796;
  void * D.22797;
  long unsigned int D.22798;
  sizetype D.22799;
  char * D.22800;
  char * start;

  start = input;
  goto <D.22379>;
  <D.22378>:
  input.11 = input;
  D.22786 = input.11 + 1;
  input = D.22786;
  <D.22379>:
  input.11 = input;
  D.22787 = *input.11;
  D.22788 = is_filenamechar (D.22787);
  if (D.22788 != 0) goto <D.22378>; else goto <D.22380>;
  <D.22380>:
  value.12 = value;
  if (value.12 != 0B) goto <D.22790>; else goto <D.22791>;
  <D.22790>:
  value.12 = value;
  monoeg_g_free (value.12);
  <D.22791>:
  input.11 = input;
  input.13 = (long int) input.11;
  start.14 = (long int) start;
  D.22794 = input.13 - start.14;
  D.22795 = D.22794 + 1;
  D.22796 = (long unsigned int) D.22795;
  D.22797 = monoeg_malloc (D.22796);
  value = D.22797;
  value.12 = value;
  input.11 = input;
  input.13 = (long int) input.11;
  start.14 = (long int) start;
  D.22794 = input.13 - start.14;
  D.22798 = (long unsigned int) D.22794;
  strncpy (value.12, start, D.22798);
  value.12 = value;
  input.11 = input;
  input.13 = (long int) input.11;
  start.14 = (long int) start;
  D.22794 = input.13 - start.14;
  D.22799 = (sizetype) D.22794;
  D.22800 = value.12 + D.22799;
  *D.22800 = 0;
}


__attribute__((__artificial__, __gnu_inline__, __always_inline__, __nothrow__, __leaf__))
strncpy (char * restrict __dest, const char * restrict __src, size_t __len)
{
  char * D.22801;
  long unsigned int D.22802;

  D.22802 = __builtin_object_size (__dest, 1);
  D.22801 = __builtin___strncpy_chk (__dest, __src, __len, D.22802);
  return D.22801;
}


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

  if (str != 0B) goto <D.22804>; else goto <D.22805>;
  <D.22804>:
  D.22806 = __strdup (str);
  return D.22806;
  <D.22805>:
  D.22806 = 0B;
  return D.22806;
}


__attribute__((__artificial__, __gnu_inline__, __always_inline__))
fprintf (struct FILE * restrict __stream, const char * restrict __fmt)
{
  int D.22808;

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


cleanup ()
{
  char * value.15;

  value.15 = value;
  if (value.15 != 0B) goto <D.22811>; else goto <D.22812>;
  <D.22811>:
  value.15 = value;
  monoeg_g_free (value.15);
  <D.22812>:
}


__attribute__((visibility ("hidden")))
mono_trace_set_assembly (struct MonoAssembly * assembly)
{
  trace_spec.assembly = assembly;
}


__attribute__((visibility ("hidden")))
mono_trace_enter_method (struct MonoMethod * method, char * ebp)
{
  int D.22813;
  void * D.22818;
  void * D.22819;
  short unsigned int D.22820;
  int D.22821;
  int D.22822;
  long unsigned int D.22823;
  long unsigned int D.22824;
  long unsigned int D.22825;
  long unsigned int D.22826;
  struct MonoDomain * D.22829;
  void * D.22830;
  void * D.22831;
  gboolean * D.22838;
  gboolean * D.22840;
  struct MonoMethodSignature * D.22841;
  struct MonoType * D.22842;
  int D.22843;
  struct MonoMethodSignature * D.22846;
  struct MonoType * D.22847;
  long unsigned int D.22848;
  long unsigned int D.22849;
  _Bool D.22850;
  long int D.22851;
  long int D.22852;
  char * D.22855;
  void * D.22856;
  struct MonoMethodSignature * D.22857;
  long unsigned int D.22858;
  long unsigned int D.22859;
  short unsigned int D.22862;
  sizetype D.22863;
  struct MonoClass * D.22864;
  long unsigned int D.22865;
  long unsigned int D.22866;
  void * * D.22869;
  struct MonoVTable * D.22873;
  struct MonoClass * D.22874;
  const char * D.22878;
  const char * D.22879;
  struct MonoDomain * D.22880;
  char * D.22881;
  sizetype D.22883;
  sizetype D.22884;
  sizetype D.22885;
  struct MonoJitArgumentInfo * D.22886;
  short unsigned int D.22887;
  sizetype D.22888;
  short unsigned int D.22889;
  struct MonoMethodSignature * D.22890;
  long unsigned int D.22891;
  long unsigned int D.22892;
  void * * D.22895;
  struct MonoType * D.22897;
  unsigned char D.22898;
  int D.22899;
  long unsigned int cpos.16;
  long unsigned int D.22901;
  gint8 * D.22902;
  signed char D.22903;
  int D.22904;
  long unsigned int D.22905;
  gint16 * D.22906;
  short int D.22907;
  int D.22908;
  long unsigned int D.22909;
  int * D.22910;
  int D.22911;
  struct MonoVTable * D.22914;
  struct MonoClass * D.22915;
  _Bool D.22916;
  long int D.22917;
  long int D.22918;
  struct MonoClass * D.22927;
  gint32 * D.22930;
  int D.22931;
  struct MonoClass * D.22933;
  struct MonoType * D.22936;
  char * D.22937;
  void * D.22940;
  long int D.22941;
  float * D.22942;
  float D.22943;
  double D.22944;
  double D.22945;
  sizetype D.22946;
  guint8 * D.22947;
  unsigned char D.22948;
  int D.22949;
  struct MonoMethodSignature * D.22950;
  short unsigned int D.22951;
  int D.22952;
  struct _IO_FILE * stdout.17;
  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.22813 = trace_spec.enabled;
  if (D.22813 == 0) goto <D.22814>; else goto <D.22815>;
  <D.22814>:
  return;
  <D.22815>:
  fname = mono_method_full_name (method, 1);
  indent (1);
  printf ("ENTER: %s(", fname);
  monoeg_g_free (fname);
  if (ebp == 0B) goto <D.22816>; else goto <D.22817>;
  <D.22816>:
  D.22818 = __builtin_return_address (1);
  D.22819 = __builtin_extract_return_addr (D.22818);
  printf (") ip: %p\n", D.22819);
  return;
  <D.22817>:
  sig = mono_method_signature (method);
  D.22820 = sig->param_count;
  D.22821 = (int) D.22820;
  D.22822 = D.22821 + 1;
  D.22823 = (long unsigned int) D.22822;
  D.22824 = D.22823 * 6;
  arg_info = __builtin_alloca (D.22824);
  D.22825 = BIT_FIELD_REF <*method, 64, 256>;
  D.22826 = D.22825 & 2251799813685248;
  if (D.22826 != 0) goto <D.22827>; else goto <D.22828>;
  <D.22827>:
  {
    struct MonoJitInfo * ji;

    D.22829 = mono_domain_get ();
    D.22830 = __builtin_return_address (0);
    D.22831 = __builtin_extract_return_addr (D.22830);
    ji = mini_jit_info_table_find (D.22829, D.22831, 0B);
    if (ji != 0B) goto <D.22832>; else goto <D.22833>;
    <D.22832>:
    gsctx = mono_jit_info_get_generic_sharing_context (ji);
    if (gsctx != 0B) goto <D.22836>; else goto <D.22837>;
    <D.22836>:
    D.22838 = gsctx->var_is_vt;
    if (D.22838 != 0B) goto <D.22834>; else goto <D.22839>;
    <D.22839>:
    D.22840 = gsctx->mvar_is_vt;
    if (D.22840 != 0B) goto <D.22834>; else goto <D.22835>;
    <D.22834>:
    printf (") <gsharedvt>\n");
    return;
    <D.22835>:
    <D.22837>:
    <D.22833>:
  }
  <D.22828>:
  D.22820 = sig->param_count;
  D.22821 = (int) D.22820;
  mono_arch_get_argument_info (gsctx, sig, D.22821, arg_info);
  D.22841 = mono_method_signature (method);
  D.22842 = D.22841->ret;
  D.22843 = mono_type_is_struct (D.22842);
  if (D.22843 != 0) goto <D.22844>; else goto <D.22845>;
  <D.22844>:
  D.22846 = mono_method_signature (method);
  D.22847 = D.22846->ret;
  D.22848 = BIT_FIELD_REF <*D.22847, 64, 64>;
  D.22849 = D.22848 & 8589934592;
  D.22850 = D.22849 != 0;
  D.22851 = (long int) D.22850;
  D.22852 = __builtin_expect (D.22851, 0);
  if (D.22852 != 0) goto <D.22853>; else goto <D.22854>;
  <D.22853>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "trace.c", 430, "!mono_method_signature (method)->ret->byref");
  <D.22854>:
  D.22855 = ebp + 8;
  D.22856 = MEM[(void * *)D.22855];
  printf ("VALUERET:%p, ", D.22856);
  <D.22845>:
  D.22857 = mono_method_signature (method);
  D.22858 = BIT_FIELD_REF <*D.22857, 64, 64>;
  D.22859 = D.22858 & 512;
  if (D.22859 != 0) goto <D.22860>; else goto <D.22861>;
  <D.22860>:
  {
    void * * this;

    D.22862 = arg_info->offset;
    D.22863 = (sizetype) D.22862;
    this = ebp + D.22863;
    D.22864 = method->klass;
    D.22865 = BIT_FIELD_REF <*D.22864, 64, 256>;
    D.22866 = D.22865 & 1152921504606846976;
    if (D.22866 != 0) goto <D.22867>; else goto <D.22868>;
    <D.22867>:
    D.22869 = MEM[(void * * *)this];
    printf ("value:%p, ", D.22869);
    goto <D.22870>;
    <D.22868>:
    o = MEM[(struct MonoObject * *)this];
    if (o != 0B) goto <D.22871>; else goto <D.22872>;
    <D.22871>:
    D.22873 = o->vtable;
    class = D.22873->klass;
    D.22874 = mono_defaults.string_class;
    if (D.22874 == class) goto <D.22875>; else goto <D.22876>;
    <D.22875>:
    {
      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.22877>;
    <D.22876>:
    D.22878 = class->name_space;
    D.22879 = class->name;
    D.22873 = o->vtable;
    D.22880 = D.22873->domain;
    D.22881 = D.22880->friendly_name;
    printf ("this:%p[%s.%s %s], ", o, D.22878, D.22879, D.22881);
    <D.22877>:
    goto <D.22882>;
    <D.22872>:
    printf ("this:NULL, ");
    <D.22882>:
    <D.22870>:
  }
  <D.22861>:
  i = 0;
  goto <D.22490>;
  <D.22489>:
  {
    void * * cpos;
    int size;
    struct MonoType * type;

    D.22883 = (sizetype) i;
    D.22884 = D.22883 + 1;
    D.22885 = D.22884 * 6;
    D.22886 = arg_info + D.22885;
    D.22887 = D.22886->offset;
    D.22888 = (sizetype) D.22887;
    cpos = ebp + D.22888;
    D.22883 = (sizetype) i;
    D.22884 = D.22883 + 1;
    D.22885 = D.22884 * 6;
    D.22886 = arg_info + D.22885;
    D.22889 = D.22886->size;
    size = (int) D.22889;
    D.22890 = mono_method_signature (method);
    type = D.22890->params[i];
    D.22891 = BIT_FIELD_REF <*type, 64, 64>;
    D.22892 = D.22891 & 8589934592;
    if (D.22892 != 0) goto <D.22893>; else goto <D.22894>;
    <D.22893>:
    D.22895 = MEM[(void * * *)cpos];
    printf ("[BYREF:%p], ", D.22895);
    goto <D.22896>;
    <D.22894>:
    D.22897 = mono_type_get_underlying_type (type);
    D.22898 = D.22897->type;
    D.22899 = (int) D.22898;
    switch (D.22899) <default: <D.22488>, case 2: <D.22462>, case 3: <D.22463>, case 4: <D.22464>, case 5: <D.22465>, case 6: <D.22466>, case 7: <D.22467>, case 8: <D.22468>, case 9: <D.22469>, case 10: <D.22480>, case 11: <D.22481>, case 12: <D.22482>, case 13: <D.22483>, case 14: <D.22470>, case 15: <D.22476>, case 17: <D.22484>, case 18: <D.22473>, case 20: <D.22478>, case 24: <D.22459>, case 25: <D.22460>, case 27: <D.22477>, case 28: <D.22474>, case 29: <D.22479>>
    <D.22459>:
    <D.22460>:
    D.22895 = MEM[(void * * *)cpos];
    printf ("%p, ", D.22895);
    goto <D.22461>;
    <D.22462>:
    <D.22463>:
    <D.22464>:
    <D.22465>:
    cpos.16 = (long unsigned int) cpos;
    D.22901 = cpos.16 + 7;
    D.22902 = (gint8 *) D.22901;
    D.22903 = *D.22902;
    D.22904 = (int) D.22903;
    printf ("%d, ", D.22904);
    goto <D.22461>;
    <D.22466>:
    <D.22467>:
    cpos.16 = (long unsigned int) cpos;
    D.22905 = cpos.16 + 6;
    D.22906 = (gint16 *) D.22905;
    D.22907 = *D.22906;
    D.22908 = (int) D.22907;
    printf ("%d, ", D.22908);
    goto <D.22461>;
    <D.22468>:
    <D.22469>:
    cpos.16 = (long unsigned int) cpos;
    D.22909 = cpos.16 + 4;
    D.22910 = (int *) D.22909;
    D.22911 = *D.22910;
    printf ("%d, ", D.22911);
    goto <D.22461>;
    <D.22470>:
    {
      struct MonoString * s;

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

        D.22914 = MEM[(struct MonoObject *)s].vtable;
        D.22915 = D.22914->klass;
        D.22874 = mono_defaults.string_class;
        D.22916 = D.22915 != D.22874;
        D.22917 = (long int) D.22916;
        D.22918 = __builtin_expect (D.22917, 0);
        if (D.22918 != 0) goto <D.22919>; else goto <D.22920>;
        <D.22919>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "trace.c", 492, "((MonoObject *)s)->vtable->klass == mono_defaults.string_class");
        <D.22920>:
        as = string_to_utf8 (s);
        printf ("[STRING:%p:%s], ", s, as);
        monoeg_g_free (as);
      }
      goto <D.22921>;
      <D.22913>:
      printf ("[STRING:null], ");
      <D.22921>:
      goto <D.22461>;
    }
    <D.22473>:
    <D.22474>:
    o = MEM[(struct MonoObject * *)cpos];
    if (o != 0B) goto <D.22922>; else goto <D.22923>;
    <D.22922>:
    D.22873 = o->vtable;
    class = D.22873->klass;
    D.22874 = mono_defaults.string_class;
    if (D.22874 == class) goto <D.22924>; else goto <D.22925>;
    <D.22924>:
    {
      char * as;

      as = string_to_utf8 (o);
      printf ("[STRING:%p:%s], ", o, as);
      monoeg_g_free (as);
    }
    goto <D.22926>;
    <D.22925>:
    D.22927 = mono_defaults.int32_class;
    if (D.22927 == class) goto <D.22928>; else goto <D.22929>;
    <D.22928>:
    D.22930 = o + 16;
    D.22931 = *D.22930;
    printf ("[INT32:%p:%d], ", o, D.22931);
    goto <D.22932>;
    <D.22929>:
    D.22933 = mono_defaults.monotype_class;
    if (D.22933 == class) goto <D.22934>; else goto <D.22935>;
    <D.22934>:
    D.22936 = MEM[(struct MonoReflectionType *)o].type;
    D.22937 = mono_type_full_name (D.22936);
    printf ("[TYPE:%s], ", D.22937);
    goto <D.22938>;
    <D.22935>:
    D.22878 = class->name_space;
    D.22879 = class->name;
    printf ("[%s.%s:%p], ", D.22878, D.22879, o);
    <D.22938>:
    <D.22932>:
    <D.22926>:
    goto <D.22939>;
    <D.22923>:
    D.22940 = *cpos;
    printf ("%p, ", D.22940);
    <D.22939>:
    goto <D.22461>;
    <D.22476>:
    <D.22477>:
    <D.22478>:
    <D.22479>:
    D.22940 = *cpos;
    printf ("%p, ", D.22940);
    goto <D.22461>;
    <D.22480>:
    <D.22481>:
    D.22941 = MEM[(gint64 *)cpos];
    printf ("0x%016llx, ", D.22941);
    goto <D.22461>;
    <D.22482>:
    cpos.16 = (long unsigned int) cpos;
    D.22909 = cpos.16 + 4;
    D.22942 = (float *) D.22909;
    D.22943 = *D.22942;
    D.22944 = (double) D.22943;
    printf ("%f, ", D.22944);
    goto <D.22461>;
    <D.22483>:
    D.22945 = MEM[(double *)cpos];
    printf ("%f, ", D.22945);
    goto <D.22461>;
    <D.22484>:
    printf ("[");
    j = 0;
    goto <D.22486>;
    <D.22485>:
    D.22946 = (sizetype) j;
    D.22947 = cpos + D.22946;
    D.22948 = *D.22947;
    D.22949 = (int) D.22948;
    printf ("%02x,", D.22949);
    j = j + 1;
    <D.22486>:
    if (j < size) goto <D.22485>; else goto <D.22487>;
    <D.22487>:
    printf ("], ");
    goto <D.22461>;
    <D.22488>:
    printf ("XX, ");
    <D.22461>:
    <D.22896>:
  }
  i = i + 1;
  <D.22490>:
  D.22950 = mono_method_signature (method);
  D.22951 = D.22950->param_count;
  D.22952 = (int) D.22951;
  if (D.22952 > i) goto <D.22489>; else goto <D.22491>;
  <D.22491>:
  printf (")\n");
  stdout.17 = stdout;
  fflush (stdout.17);
}


indent (int diff)
{
  int indent_level.18;
  int D.22958;
  long unsigned int start_time.19;
  long int D.22962;
  long unsigned int D.22963;
  long unsigned int D.22964;
  void * D.22965;
  double D.22966;

  if (diff < 0) goto <D.22955>; else goto <D.22956>;
  <D.22955>:
  indent_level.18 = indent_level;
  D.22958 = indent_level.18 + diff;
  indent_level = D.22958;
  <D.22956>:
  start_time.19 = start_time;
  if (start_time.19 == 0) goto <D.22960>; else goto <D.22961>;
  <D.22960>:
  D.22962 = mono_100ns_ticks ();
  D.22963 = (long unsigned int) D.22962;
  start_time = D.22963;
  <D.22961>:
  D.22964 = GetCurrentThreadId ();
  D.22965 = (void *) D.22964;
  D.22966 = seconds_since_start ();
  indent_level.18 = indent_level;
  printf ("[%p: %.5f %d] ", D.22965, D.22966, indent_level.18);
  if (diff > 0) goto <D.22967>; else goto <D.22968>;
  <D.22967>:
  indent_level.18 = indent_level;
  D.22958 = indent_level.18 + diff;
  indent_level = D.22958;
  <D.22968>:
}


seconds_since_start ()
{
  long int D.22969;
  long unsigned int D.22970;
  long unsigned int start_time.20;
  double D.22972;
  double D.22973;
  guint64 diff;

  D.22969 = mono_100ns_ticks ();
  D.22970 = (long unsigned int) D.22969;
  start_time.20 = start_time;
  diff = D.22970 - start_time.20;
  D.22973 = (double) diff;
  D.22972 = D.22973 / 1.0e+7;
  return D.22972;
}


string_to_utf8 (struct MonoString * s)
{
  _Bool D.22975;
  long int D.22976;
  long int D.22977;
  int D.22980;
  char * D.22983;
  mono_unichar2 * D.22984;
  long int D.22985;
  struct GError * error.21;
  char * as;
  struct GError * error;

  try
    {
      error = 0B;
      D.22975 = s == 0B;
      D.22976 = (long int) D.22975;
      D.22977 = __builtin_expect (D.22976, 0);
      if (D.22977 != 0) goto <D.22978>; else goto <D.22979>;
      <D.22978>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "trace.c", 355, "s");
      <D.22979>:
      D.22980 = s->length;
      if (D.22980 == 0) goto <D.22981>; else goto <D.22982>;
      <D.22981>:
      D.22983 = monoeg_strdup ("");
      return D.22983;
      <D.22982>:
      D.22984 = mono_string_chars (s);
      D.22980 = s->length;
      D.22985 = (long int) D.22980;
      as = monoeg_g_utf16_to_utf8 (D.22984, D.22985, 0B, 0B, &error);
      error.21 = error;
      if (error.21 != 0B) goto <D.22987>; else goto <D.22988>;
      <D.22987>:
      error.21 = error;
      monoeg_g_error_free (error.21);
      D.22983 = monoeg_strdup ("<INVALID UTF8>");
      return D.22983;
      <D.22988>:
      D.22983 = as;
      return D.22983;
    }
  finally
    {
      error = {CLOBBER};
    }
}


__attribute__((__artificial__, __gnu_inline__, __always_inline__))
printf (const char * restrict __fmt)
{
  int D.22991;

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


__attribute__((visibility ("hidden")))
mono_trace_leave_method (struct MonoMethod * method)
{
  int D.22993;
  long unsigned int D.22996;
  long unsigned int D.22997;
  struct MonoDomain * D.23000;
  void * D.23001;
  void * D.23002;
  gboolean * D.23009;
  gboolean * D.23011;
  struct MonoMethodSignature * D.23012;
  unsigned char D.23013;
  int D.23014;
  struct MonoVTable * D.23020;
  struct MonoClass * D.23021;
  struct MonoClass * D.23022;
  _Bool D.23023;
  long int D.23024;
  long int D.23025;
  struct MonoVTable * D.23031;
  struct MonoClass * D.23032;
  struct MonoClass * D.23033;
  guint8 * D.23036;
  unsigned char D.23037;
  int D.23038;
  struct MonoClass * D.23040;
  gint32 * D.23043;
  int D.23044;
  struct MonoClass * D.23046;
  gint64 * D.23049;
  long int D.23050;
  const char * D.23052;
  const char * D.23053;
  struct MonoClass * D.23055;
  long unsigned int D.23056;
  long unsigned int D.23057;
  sizetype D.23060;
  guint8 * D.23061;
  unsigned char D.23062;
  int D.23063;
  struct MonoMethodSignature * D.23065;
  struct MonoType * D.23066;
  unsigned char D.23067;
  int D.23068;
  struct _IO_FILE * stdout.22;
  struct MonoType * type;
  char * fname;
  struct  ap[1];
  struct MonoGenericSharingContext * gsctx;
  void handle_enum = <<< error >>>;

  try
    {
      D.22993 = trace_spec.enabled;
      if (D.22993 == 0) goto <D.22994>; else goto <D.22995>;
      <D.22994>:
      return;
      <D.22995>:
      __builtin_va_start (&ap, 0);
      fname = mono_method_full_name (method, 1);
      indent (-1);
      printf ("LEAVE: %s", fname);
      monoeg_g_free (fname);
      D.22996 = BIT_FIELD_REF <*method, 64, 256>;
      D.22997 = D.22996 & 2251799813685248;
      if (D.22997 != 0) goto <D.22998>; else goto <D.22999>;
      <D.22998>:
      {
        struct MonoJitInfo * ji;

        D.23000 = mono_domain_get ();
        D.23001 = __builtin_return_address (0);
        D.23002 = __builtin_extract_return_addr (D.23001);
        ji = mini_jit_info_table_find (D.23000, D.23002, 0B);
        if (ji != 0B) goto <D.23003>; else goto <D.23004>;
        <D.23003>:
        gsctx = mono_jit_info_get_generic_sharing_context (ji);
        if (gsctx != 0B) goto <D.23007>; else goto <D.23008>;
        <D.23007>:
        D.23009 = gsctx->var_is_vt;
        if (D.23009 != 0B) goto <D.23005>; else goto <D.23010>;
        <D.23010>:
        D.23011 = gsctx->mvar_is_vt;
        if (D.23011 != 0B) goto <D.23005>; else goto <D.23006>;
        <D.23005>:
        printf (") <gsharedvt>\n");
        return;
        <D.23006>:
        <D.23008>:
        <D.23004>:
      }
      <D.22999>:
      D.23012 = mono_method_signature (method);
      type = D.23012->ret;
      handle_enum:
      D.23013 = type->type;
      D.23014 = (int) D.23013;
      switch (D.23014) <default: <D.22541>, case 1: <D.22501>, case 2: <D.22503>, case 3: <D.22505>, case 4: <D.22506>, case 5: <D.22507>, case 6: <D.22508>, case 7: <D.22509>, case 8: <D.22510>, case 9: <D.22511>, case 10: <D.22526>, case 11: <D.22528>, case 12: <D.22530>, case 13: <D.22531>, case 14: <D.22515>, case 15: <D.22521>, case 17: <D.22533>, case 18: <D.22518>, case 20: <D.22523>, case 24: <D.22512>, case 25: <D.22513>, case 27: <D.22522>, case 28: <D.22519>, case 29: <D.22524>>
      <D.22501>:
      goto <D.22502>;
      <D.22503>:
      {
        int eax;

        eax = VA_ARG (&ap, 0B, 0B);
        if (eax != 0) goto <D.23015>; else goto <D.23016>;
        <D.23015>:
        printf ("TRUE:%d", eax);
        goto <D.23017>;
        <D.23016>:
        printf ("FALSE");
        <D.23017>:
        goto <D.22502>;
      }
      <D.22505>:
      <D.22506>:
      <D.22507>:
      <D.22508>:
      <D.22509>:
      <D.22510>:
      <D.22511>:
      <D.22512>:
      <D.22513>:
      {
        int eax;

        eax = VA_ARG (&ap, 0B, 0B);
        printf ("result=%d", eax);
        goto <D.22502>;
      }
      <D.22515>:
      {
        struct MonoString * s;

        s = VA_ARG (&ap, 0B, 0B);
        if (s != 0B) goto <D.23018>; else goto <D.23019>;
        <D.23018>:
        {
          char * as;

          D.23020 = MEM[(struct MonoObject *)s].vtable;
          D.23021 = D.23020->klass;
          D.23022 = mono_defaults.string_class;
          D.23023 = D.23021 != D.23022;
          D.23024 = (long int) D.23023;
          D.23025 = __builtin_expect (D.23024, 0);
          if (D.23025 != 0) goto <D.23026>; else goto <D.23027>;
          <D.23026>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "trace.c", 619, "((MonoObject *)s)->vtable->klass == mono_defaults.string_class");
          <D.23027>:
          as = string_to_utf8 (s);
          printf ("[STRING:%p:%s]", s, as);
          monoeg_g_free (as);
        }
        goto <D.23028>;
        <D.23019>:
        printf ("[STRING:null], ");
        <D.23028>:
        goto <D.22502>;
      }
      <D.22518>:
      <D.22519>:
      {
        struct MonoObject * o;

        o = VA_ARG (&ap, 0B, 0B);
        if (o != 0B) goto <D.23029>; else goto <D.23030>;
        <D.23029>:
        D.23031 = o->vtable;
        D.23032 = D.23031->klass;
        D.23033 = mono_defaults.boolean_class;
        if (D.23032 == D.23033) goto <D.23034>; else goto <D.23035>;
        <D.23034>:
        D.23036 = o + 16;
        D.23037 = *D.23036;
        D.23038 = (int) D.23037;
        printf ("[BOOLEAN:%p:%d]", o, D.23038);
        goto <D.23039>;
        <D.23035>:
        D.23031 = o->vtable;
        D.23032 = D.23031->klass;
        D.23040 = mono_defaults.int32_class;
        if (D.23032 == D.23040) goto <D.23041>; else goto <D.23042>;
        <D.23041>:
        D.23043 = o + 16;
        D.23044 = *D.23043;
        printf ("[INT32:%p:%d]", o, D.23044);
        goto <D.23045>;
        <D.23042>:
        D.23031 = o->vtable;
        D.23032 = D.23031->klass;
        D.23046 = mono_defaults.int64_class;
        if (D.23032 == D.23046) goto <D.23047>; else goto <D.23048>;
        <D.23047>:
        D.23049 = o + 16;
        D.23050 = *D.23049;
        printf ("[INT64:%p:%lld]", o, D.23050);
        goto <D.23051>;
        <D.23048>:
        D.23031 = o->vtable;
        D.23032 = D.23031->klass;
        D.23052 = D.23032->name_space;
        D.23031 = o->vtable;
        D.23032 = D.23031->klass;
        D.23053 = D.23032->name;
        printf ("[%s.%s:%p]", D.23052, D.23053, o);
        <D.23051>:
        <D.23045>:
        <D.23039>:
        goto <D.23054>;
        <D.23030>:
        printf ("[OBJECT:%p]", o);
        <D.23054>:
        goto <D.22502>;
      }
      <D.22521>:
      <D.22522>:
      <D.22523>:
      <D.22524>:
      {
        void * p;

        p = VA_ARG (&ap, 0B, 0B);
        printf ("result=%p", p);
        goto <D.22502>;
      }
      <D.22526>:
      {
        gint64 l;

        l = VA_ARG (&ap, 0B, 0B);
        printf ("lresult=0x%16llx", l);
        goto <D.22502>;
      }
      <D.22528>:
      {
        gint64 l;

        l = VA_ARG (&ap, 0B, 0B);
        printf ("lresult=0x%16llx", l);
        goto <D.22502>;
      }
      <D.22530>:
      <D.22531>:
      {
        double f;

        f = VA_ARG (&ap, 0B, 0B);
        printf ("FP=%f", f);
        goto <D.22502>;
      }
      <D.22533>:
      D.23055 = type->data.klass;
      D.23056 = BIT_FIELD_REF <*D.23055, 64, 256>;
      D.23057 = D.23056 & 576460752303423488;
      if (D.23057 != 0) goto <D.23058>; else goto <D.23059>;
      <D.23058>:
      D.23055 = type->data.klass;
      type = mono_class_enum_basetype (D.23055);
      goto handle_enum;
      <D.23059>:
      {
        guint8 * p;
        int j;
        int size;
        int align;

        try
          {
            p = VA_ARG (&ap, 0B, 0B);
            size = mono_type_size (type, &align);
            printf ("[");
            j = 0;
            goto <D.22539>;
            <D.22538>:
            D.23060 = (sizetype) j;
            D.23061 = p + D.23060;
            D.23062 = *D.23061;
            D.23063 = (int) D.23062;
            printf ("%02x,", D.23063);
            j = j + 1;
            <D.22539>:
            if (p != 0B) goto <D.23064>; else goto <D.22540>;
            <D.23064>:
            if (j < size) goto <D.22538>; else goto <D.22540>;
            <D.22540>:
            printf ("]");
          }
        finally
          {
            align = {CLOBBER};
          }
      }
      goto <D.22502>;
      <D.22541>:
      D.23065 = mono_method_signature (method);
      D.23066 = D.23065->ret;
      D.23067 = D.23066->type;
      D.23068 = (int) D.23067;
      printf ("(unknown return type %x)", D.23068);
      <D.22502>:
      printf ("\n");
      stdout.22 = stdout;
      fflush (stdout.22);
    }
  finally
    {
      ap = {CLOBBER};
    }
}


__attribute__((visibility ("hidden")))
mono_trace_enable (gboolean enable)
{
  trace_spec.enabled = enable;
}


__attribute__((visibility ("hidden")))
mono_trace_is_enabled ()
{
  gboolean D.23074;

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