__attribute__((visibility ("hidden")))
mono_hw_reg_to_dwarf_reg (int reg)
{
  int D.22551;

  if (0 != 0) goto <D.22549>; else goto <D.22550>;
  <D.22549>:
  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "unwind.c", 126);
  D.22551 = -1;
  return D.22551;
  <D.22550>:
  D.22551 = map_hw_reg_to_dwarf_reg[reg];
  return D.22551;
}


__attribute__((visibility ("hidden")))
mono_dwarf_reg_to_hw_reg (int reg)
{
  int dwarf_reg_to_hw_reg_inited.0;
  int D.22556;

  dwarf_reg_to_hw_reg_inited.0 = dwarf_reg_to_hw_reg_inited;
  if (dwarf_reg_to_hw_reg_inited.0 == 0) goto <D.22554>; else goto <D.22555>;
  <D.22554>:
  init_reg_map ();
  <D.22555>:
  D.22556 = map_dwarf_reg_to_hw_reg[reg];
  return D.22556;
}


init_reg_map ()
{
  int D.22560;
  unsigned int i.1;
  int i;

  if (0 != 0) goto <D.22558>; else goto <D.22559>;
  <D.22558>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "unwind.c", 138, "NUM_REGS > 0");
  <D.22559>:
  i = 0;
  goto <D.22223>;
  <D.22222>:
  D.22560 = mono_hw_reg_to_dwarf_reg (i);
  map_dwarf_reg_to_hw_reg[D.22560] = i;
  i = i + 1;
  <D.22223>:
  i.1 = (unsigned int) i;
  if (i.1 <= 15) goto <D.22222>; else goto <D.22224>;
  <D.22224>:
  mono_memory_barrier ();
  dwarf_reg_to_hw_reg_inited = 1;
}


mono_memory_barrier ()
{
  __sync_synchronize ();
}


__attribute__((visibility ("hidden")))
mono_print_unwind_info (guint8 * unwind_info, int unwind_info_len)
{
  guint8 * p.2;
  unsigned char D.22563;
  int D.22564;
  int D.22565;
  guint8 * p.3;
  unsigned int D.22567;
  unsigned int D.22568;
  int D.22569;
  int D.22572;
  int D.22574;
  const char * D.22575;
  unsigned int D.22576;
  unsigned int D.22577;
  int D.22578;
  const char * D.22579;
  unsigned int D.22580;
  unsigned int D.22581;
  int D.22582;
  const char * D.22583;
  unsigned int D.22584;
  int D.22585;
  int D.22586;
  const char * D.22587;
  unsigned int D.22588;
  unsigned int D.22589;
  unsigned int D.22590;
  unsigned int D.22591;
  unsigned int D.22592;
  unsigned int D.22593;
  unsigned int D.22594;
  unsigned int D.22595;
  unsigned int D.22596;
  unsigned int D.22597;
  unsigned int pos.4;
  unsigned int D.22599;
  guint8 * p.5;
  sizetype D.22601;
  guint8 * D.22602;
  guint8 * p;
  int pos;
  int reg;
  int offset;
  int cfa_reg;
  int cfa_offset;

  try
    {
      p = unwind_info;
      pos = 0;
      goto <D.22295>;
      <D.22294>:
      {
        int op;

        p.2 = p;
        D.22563 = *p.2;
        D.22564 = (int) D.22563;
        op = D.22564 & 192;
        switch (op) <default: <D.22293>, case 0: <D.22284>, case 64: <D.22281>, case 128: <D.22283>>
        <D.22281>:
        p.2 = p;
        D.22563 = *p.2;
        D.22564 = (int) D.22563;
        D.22565 = D.22564 & 63;
        pos = D.22565 + pos;
        p.2 = p;
        p.3 = p.2 + 1;
        p = p.3;
        goto <D.22282>;
        <D.22283>:
        p.2 = p;
        D.22563 = *p.2;
        D.22564 = (int) D.22563;
        reg = D.22564 & 63;
        p.2 = p;
        p.3 = p.2 + 1;
        p = p.3;
        p.2 = p;
        D.22567 = decode_uleb128 (p.2, &p);
        D.22568 = D.22567 * 4294967288;
        offset = (int) D.22568;
        D.22569 = mono_hw_reg_to_dwarf_reg (14);
        if (D.22569 == reg) goto <D.22570>; else goto <D.22571>;
        <D.22570>:
        D.22572 = -offset;
        printf ("CFA: [%x] offset: %s at cfa-0x%x\n", pos, "pc", D.22572);
        goto <D.22573>;
        <D.22571>:
        D.22574 = mono_dwarf_reg_to_hw_reg (reg);
        D.22575 = mono_arch_regname (D.22574);
        D.22572 = -offset;
        printf ("CFA: [%x] offset: %s at cfa-0x%x\n", pos, D.22575, D.22572);
        <D.22573>:
        goto <D.22282>;
        <D.22284>:
        {
          int ext_op;

          p.2 = p;
          D.22563 = *p.2;
          ext_op = (int) D.22563;
          p.2 = p;
          p.3 = p.2 + 1;
          p = p.3;
          switch (ext_op) <default: <D.22292>, case 4: <D.22291>, case 12: <D.22286>, case 13: <D.22289>, case 14: <D.22288>, case 17: <D.22290>>
          <D.22286>:
          p.2 = p;
          D.22576 = decode_uleb128 (p.2, &p);
          cfa_reg = (int) D.22576;
          p.2 = p;
          D.22577 = decode_uleb128 (p.2, &p);
          cfa_offset = (int) D.22577;
          D.22578 = mono_dwarf_reg_to_hw_reg (cfa_reg);
          D.22579 = mono_arch_regname (D.22578);
          printf ("CFA: [%x] def_cfa: %s+0x%x\n", pos, D.22579, cfa_offset);
          goto <D.22287>;
          <D.22288>:
          p.2 = p;
          D.22580 = decode_uleb128 (p.2, &p);
          cfa_offset = (int) D.22580;
          printf ("CFA: [%x] def_cfa_offset: 0x%x\n", pos, cfa_offset);
          goto <D.22287>;
          <D.22289>:
          p.2 = p;
          D.22581 = decode_uleb128 (p.2, &p);
          cfa_reg = (int) D.22581;
          D.22582 = mono_dwarf_reg_to_hw_reg (cfa_reg);
          D.22583 = mono_arch_regname (D.22582);
          printf ("CFA: [%x] def_cfa_reg: %s\n", pos, D.22583);
          goto <D.22287>;
          <D.22290>:
          p.2 = p;
          D.22584 = decode_uleb128 (p.2, &p);
          reg = (int) D.22584;
          p.2 = p;
          D.22585 = decode_sleb128 (p.2, &p);
          offset = D.22585 * -8;
          D.22586 = mono_dwarf_reg_to_hw_reg (reg);
          D.22587 = mono_arch_regname (D.22586);
          D.22572 = -offset;
          printf ("CFA: [%x] offset_extended_sf: %s at cfa-0x%x\n", pos, D.22587, D.22572);
          goto <D.22287>;
          <D.22291>:
          p.2 = p;
          D.22588 = MEM[(const guint32 *)p.2];
          D.22589 = D.22588 << 24;
          p.2 = p;
          D.22588 = MEM[(const guint32 *)p.2];
          D.22590 = D.22588 >> 8;
          D.22591 = D.22590 & 65280;
          D.22592 = D.22589 | D.22591;
          p.2 = p;
          D.22588 = MEM[(const guint32 *)p.2];
          D.22593 = D.22588 << 8;
          D.22594 = D.22593 & 16711680;
          D.22595 = D.22592 | D.22594;
          p.2 = p;
          D.22588 = MEM[(const guint32 *)p.2];
          D.22596 = D.22588 >> 24;
          D.22597 = D.22595 | D.22596;
          pos.4 = (unsigned int) pos;
          D.22599 = D.22597 + pos.4;
          pos = (int) D.22599;
          p.2 = p;
          p.5 = p.2 + 4;
          p = p.5;
          goto <D.22287>;
          <D.22292>:
          monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "unwind.c", 306);
          <D.22287>:
          goto <D.22282>;
        }
        <D.22293>:
        monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "unwind.c", 311);
        <D.22282>:
      }
      <D.22295>:
      D.22601 = (sizetype) unwind_info_len;
      D.22602 = unwind_info + D.22601;
      p.2 = p;
      if (D.22602 > p.2) goto <D.22294>; else goto <D.22296>;
      <D.22296>:
    }
  finally
    {
      p = {CLOBBER};
    }
}


decode_uleb128 (guint8 * buf, guint8 * * endbuf)
{
  int D.22603;
  int D.22604;
  int D.22605;
  unsigned int D.22606;
  signed char b.6;
  guint32 D.22609;
  guint8 * p;
  guint32 res;
  int shift;

  p = buf;
  res = 0;
  shift = 0;
  <D.22259>:
  {
    guint8 b;

    b = *p;
    p = p + 1;
    D.22603 = (int) b;
    D.22604 = D.22603 & 127;
    D.22605 = D.22604 << shift;
    D.22606 = (unsigned int) D.22605;
    res = D.22606 | res;
    b.6 = (signed char) b;
    if (b.6 >= 0) goto <D.22258>; else goto <D.22608>;
    <D.22608>:
    shift = shift + 7;
  }
  goto <D.22259>;
  <D.22258>:
  *endbuf = p;
  D.22609 = res;
  return D.22609;
}


decode_sleb128 (guint8 * buf, guint8 * * endbuf)
{
  int D.22611;
  int D.22612;
  int D.22613;
  signed char b.7;
  int D.22619;
  int D.22622;
  int D.22623;
  gint32 D.22624;
  guint8 * p;
  gint32 res;
  int shift;

  p = buf;
  res = 0;
  shift = 0;
  <D.22269>:
  {
    guint8 b;

    b = *p;
    p = p + 1;
    D.22611 = (int) b;
    D.22612 = D.22611 & 127;
    D.22613 = D.22612 << shift;
    res = D.22613 | res;
    shift = shift + 7;
    b.7 = (signed char) b;
    if (b.7 >= 0) goto <D.22615>; else goto <D.22616>;
    <D.22615>:
    if (shift <= 31) goto <D.22617>; else goto <D.22618>;
    <D.22617>:
    D.22611 = (int) b;
    D.22619 = D.22611 & 64;
    if (D.22619 != 0) goto <D.22620>; else goto <D.22621>;
    <D.22620>:
    D.22622 = 1 << shift;
    D.22623 = -D.22622;
    res = D.22623 | res;
    <D.22621>:
    <D.22618>:
    goto <D.22268>;
    <D.22616>:
  }
  goto <D.22269>;
  <D.22268>:
  *endbuf = p;
  D.22624 = res;
  return D.22624;
}


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

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


__attribute__((visibility ("hidden")))
mono_unwind_ops_encode (struct GSList * unwind_ops, guint32 * out_len)
{
  short unsigned int D.22628;
  int D.22629;
  unsigned int D.22630;
  unsigned int loc.8;
  unsigned int D.22632;
  guint8 * p.9;
  guint8 * p.10;
  guint8 * p.11;
  unsigned char D.22638;
  unsigned char D.22639;
  unsigned char D.22640;
  unsigned char D.22641;
  guint8 * p.12;
  guint8 * p.13;
  unsigned char D.22645;
  int D.22646;
  guint8 * p.14;
  guint8 * p.15;
  unsigned int reg.16;
  int D.22650;
  unsigned int D.22651;
  guint8 * p.17;
  guint8 * p.18;
  guint8 * p.19;
  guint8 * p.20;
  guint8 * p.21;
  guint8 * p.22;
  int D.22660;
  guint8 * p.23;
  guint8 * p.24;
  signed char D.22664;
  signed char D.22665;
  unsigned char D.22666;
  unsigned int D.22667;
  long int p.25;
  long int buf.26;
  long int D.22670;
  _Bool D.22671;
  long int D.22672;
  long int D.22673;
  unsigned int D.22676;
  long unsigned int D.22677;
  long unsigned int D.22678;
  guint8 * D.22679;
  struct GSList * l;
  struct MonoUnwindOp * op;
  int loc;
  guint8 * buf;
  guint8 * p;
  guint8 * res;

  try
    {
      buf = monoeg_malloc0 (4096);
      p = buf;
      loc = 0;
      l = unwind_ops;
      goto <D.22318>;
      <D.22317>:
      {
        int reg;

        op = l->data;
        D.22628 = op->reg;
        D.22629 = (int) D.22628;
        reg = mono_hw_reg_to_dwarf_reg (D.22629);
        goto <D.22309>;
        <D.22308>:
        D.22630 = op->when;
        loc.8 = (unsigned int) loc;
        D.22632 = D.22630 - loc.8;
        if (D.22632 <= 31) goto <D.22633>; else goto <D.22634>;
        <D.22633>:
        p.9 = p;
        p.10 = p.9;
        p.11 = p.10 + 1;
        p = p.11;
        D.22630 = op->when;
        D.22638 = (unsigned char) D.22630;
        D.22639 = (unsigned char) loc;
        D.22640 = D.22638 - D.22639;
        D.22641 = D.22640 | 64;
        *p.10 = D.22641;
        D.22630 = op->when;
        loc = (int) D.22630;
        goto <D.22642>;
        <D.22634>:
        p.9 = p;
        p.12 = p.9;
        p.13 = p.12 + 1;
        p = p.13;
        *p.12 = 94;
        loc = loc + 30;
        <D.22642>:
        <D.22309>:
        D.22630 = op->when;
        loc.8 = (unsigned int) loc;
        if (D.22630 > loc.8) goto <D.22308>; else goto <D.22310>;
        <D.22310>:
        D.22645 = op->op;
        D.22646 = (int) D.22645;
        switch (D.22646) <default: <D.22316>, case 12: <D.22311>, case 13: <D.22314>, case 14: <D.22313>, case 128: <D.22315>>
        <D.22311>:
        p.9 = p;
        p.14 = p.9;
        p.15 = p.14 + 1;
        p = p.15;
        D.22645 = op->op;
        *p.14 = D.22645;
        reg.16 = (unsigned int) reg;
        p.9 = p;
        encode_uleb128 (reg.16, p.9, &p);
        D.22650 = op->val;
        D.22651 = (unsigned int) D.22650;
        p.9 = p;
        encode_uleb128 (D.22651, p.9, &p);
        goto <D.22312>;
        <D.22313>:
        p.9 = p;
        p.17 = p.9;
        p.18 = p.17 + 1;
        p = p.18;
        D.22645 = op->op;
        *p.17 = D.22645;
        D.22650 = op->val;
        D.22651 = (unsigned int) D.22650;
        p.9 = p;
        encode_uleb128 (D.22651, p.9, &p);
        goto <D.22312>;
        <D.22314>:
        p.9 = p;
        p.19 = p.9;
        p.20 = p.19 + 1;
        p = p.20;
        D.22645 = op->op;
        *p.19 = D.22645;
        reg.16 = (unsigned int) reg;
        p.9 = p;
        encode_uleb128 (reg.16, p.9, &p);
        goto <D.22312>;
        <D.22315>:
        if (reg > 63) goto <D.22656>; else goto <D.22657>;
        <D.22656>:
        p.9 = p;
        p.21 = p.9;
        p.22 = p.21 + 1;
        p = p.22;
        *p.21 = 17;
        reg.16 = (unsigned int) reg;
        p.9 = p;
        encode_uleb128 (reg.16, p.9, &p);
        D.22650 = op->val;
        D.22660 = D.22650 / -8;
        p.9 = p;
        encode_sleb128 (D.22660, p.9, &p);
        goto <D.22661>;
        <D.22657>:
        p.9 = p;
        p.23 = p.9;
        p.24 = p.23 + 1;
        p = p.24;
        D.22664 = (signed char) reg;
        D.22665 = D.22664 | -128;
        D.22666 = (unsigned char) D.22665;
        *p.23 = D.22666;
        D.22650 = op->val;
        D.22660 = D.22650 / -8;
        D.22667 = (unsigned int) D.22660;
        p.9 = p;
        encode_uleb128 (D.22667, p.9, &p);
        <D.22661>:
        goto <D.22312>;
        <D.22316>:
        monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "unwind.c", 378);
        <D.22312>:
      }
      l = l->next;
      <D.22318>:
      if (l != 0B) goto <D.22317>; else goto <D.22319>;
      <D.22319>:
      p.9 = p;
      p.25 = (long int) p.9;
      buf.26 = (long int) buf;
      D.22670 = p.25 - buf.26;
      D.22671 = D.22670 > 4095;
      D.22672 = (long int) D.22671;
      D.22673 = __builtin_expect (D.22672, 0);
      if (D.22673 != 0) goto <D.22674>; else goto <D.22675>;
      <D.22674>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "unwind.c", 383, "p - buf < 4096");
      <D.22675>:
      p.9 = p;
      p.25 = (long int) p.9;
      buf.26 = (long int) buf;
      D.22670 = p.25 - buf.26;
      D.22676 = (unsigned int) D.22670;
      *out_len = D.22676;
      p.9 = p;
      p.25 = (long int) p.9;
      buf.26 = (long int) buf;
      D.22670 = p.25 - buf.26;
      D.22677 = (long unsigned int) D.22670;
      res = monoeg_malloc (D.22677);
      p.9 = p;
      p.25 = (long int) p.9;
      buf.26 = (long int) buf;
      D.22670 = p.25 - buf.26;
      D.22678 = (long unsigned int) D.22670;
      memcpy (res, buf, D.22678);
      monoeg_g_free (buf);
      D.22679 = res;
      return D.22679;
    }
  finally
    {
      p = {CLOBBER};
    }
}


__attribute__((__unused__))
encode_sleb128 (gint32 value, guint8 * buf, guint8 * * endbuf)
{
  _Bool D.22682;
  unsigned char D.22683;
  unsigned int D.22686;
  int D.22687;
  int D.22688;
  int D.22694;
  int D.22695;
  guint8 * p.27;
  gboolean more;
  gboolean negative;
  guint32 size;
  guint8 byte;
  guint8 * p;

  more = 1;
  D.22682 = value < 0;
  negative = (gboolean) D.22682;
  size = 32;
  p = buf;
  goto <D.22248>;
  <D.22247>:
  D.22683 = (unsigned char) value;
  byte = D.22683 & 127;
  value = value >> 7;
  if (negative != 0) goto <D.22684>; else goto <D.22685>;
  <D.22684>:
  D.22686 = size + 4294967289;
  D.22687 = 1 << D.22686;
  D.22688 = -D.22687;
  value = D.22688 | value;
  <D.22685>:
  if (value == 0) goto <D.22693>; else goto <D.22689>;
  <D.22693>:
  D.22694 = (int) byte;
  D.22695 = D.22694 & 64;
  if (D.22695 == 0) goto <D.22690>; else goto <D.22689>;
  <D.22689>:
  if (value == -1) goto <D.22696>; else goto <D.22691>;
  <D.22696>:
  D.22694 = (int) byte;
  D.22695 = D.22694 & 64;
  if (D.22695 != 0) goto <D.22690>; else goto <D.22691>;
  <D.22690>:
  more = 0;
  goto <D.22692>;
  <D.22691>:
  byte = byte | 128;
  <D.22692>:
  p.27 = p;
  p = p.27 + 1;
  *p.27 = byte;
  <D.22248>:
  if (more != 0) goto <D.22247>; else goto <D.22249>;
  <D.22249>:
  *endbuf = p;
}


__attribute__((__unused__))
encode_uleb128 (guint32 value, guint8 * buf, guint8 * * endbuf)
{
  unsigned char D.22698;
  guint8 * p.28;
  guint8 * p;

  p = buf;
  <D.22235>:
  {
    guint8 b;

    D.22698 = (unsigned char) value;
    b = D.22698 & 127;
    value = value >> 7;
    if (value != 0) goto <D.22699>; else goto <D.22700>;
    <D.22699>:
    b = b | 128;
    <D.22700>:
    p.28 = p;
    p = p.28 + 1;
    *p.28 = b;
  }
  if (value != 0) goto <D.22235>; else goto <D.22236>;
  <D.22236>:
  *endbuf = p;
}


__attribute__((__artificial__, __gnu_inline__, __always_inline__, __nothrow__, __leaf__))
memcpy (void * restrict __dest, const void * restrict __src, size_t __len)
{
  void * D.22702;
  long unsigned int D.22703;

  D.22703 = __builtin_object_size (__dest, 0);
  D.22702 = __builtin___memcpy_chk (__dest, __src, __len, D.22703);
  return D.22702;
}


__attribute__((visibility ("hidden")))
mono_unwind_frame (guint8 * unwind_info, guint32 unwind_info_len, guint8 * start_ip, guint8 * end_ip, guint8 * ip, mgreg_t * regs, int nregs, mgreg_t * * save_locations, int save_locations_len, guint8 * * out_cfa)
{
  guint8 * p.29;
  unsigned char D.22706;
  int D.22707;
  int D.22708;
  guint8 * p.30;
  unsigned int D.22710;
  unsigned int D.22711;
  int D.22712;
  unsigned int D.22713;
  unsigned int D.22714;
  unsigned int D.22715;
  unsigned int D.22716;
  unsigned int D.22717;
  _Bool D.22718;
  long int D.22719;
  long int D.22720;
  int D.22723;
  unsigned int D.22724;
  unsigned int D.22725;
  unsigned int D.22728;
  unsigned int D.22729;
  unsigned int D.22730;
  unsigned int D.22731;
  unsigned int D.22732;
  unsigned int D.22733;
  unsigned int D.22734;
  unsigned int D.22735;
  unsigned int D.22736;
  unsigned int D.22737;
  unsigned int pos.31;
  unsigned int D.22739;
  guint8 * p.32;
  long int D.22741;
  long int ip.33;
  long int start_ip.34;
  long int D.22744;
  sizetype D.22746;
  guint8 * D.22747;
  long unsigned int D.22750;
  long unsigned int D.22751;
  sizetype D.22752;
  int D.22753;
  long unsigned int D.22754;
  long unsigned int D.22755;
  mgreg_t * D.22756;
  long int D.22757;
  sizetype D.22758;
  sizetype D.22759;
  unsigned char D.22760;
  <unnamed type> D.22763;
  _Bool D.22766;
  long int D.22767;
  long int D.22768;
  long unsigned int D.22771;
  long unsigned int D.22772;
  mgreg_t * D.22773;
  int D.22774;
  sizetype D.22775;
  guint8 * D.22776;
  long int D.22777;
  mgreg_t * * D.22782;
  struct Loc locations[16];
  guint8 reg_saved[16];
  int i;
  int pos;
  int reg;
  int cfa_reg;
  int cfa_offset;
  int offset;
  guint8 * p;
  guint8 * cfa_val;

  try
    {
      memset (&reg_saved, 0, 16);
      p = unwind_info;
      pos = 0;
      cfa_reg = -1;
      cfa_offset = -1;
      goto <D.22370>;
      <D.22369>:
      {
        int op;

        p.29 = p;
        D.22706 = *p.29;
        D.22707 = (int) D.22706;
        op = D.22707 & 192;
        switch (op) <default: <D.22368>, case 0: <D.22358>, case 64: <D.22355>, case 128: <D.22357>>
        <D.22355>:
        p.29 = p;
        D.22706 = *p.29;
        D.22707 = (int) D.22706;
        D.22708 = D.22707 & 63;
        pos = D.22708 + pos;
        p.29 = p;
        p.30 = p.29 + 1;
        p = p.30;
        goto <D.22356>;
        <D.22357>:
        p.29 = p;
        D.22706 = *p.29;
        D.22707 = (int) D.22706;
        reg = D.22707 & 63;
        p.29 = p;
        p.30 = p.29 + 1;
        p = p.30;
        reg_saved[reg] = 1;
        locations[reg].loc_type = 1;
        p.29 = p;
        D.22710 = decode_uleb128 (p.29, &p);
        D.22711 = D.22710 * 4294967288;
        D.22712 = (int) D.22711;
        locations[reg].offset = D.22712;
        goto <D.22356>;
        <D.22358>:
        {
          int ext_op;

          p.29 = p;
          D.22706 = *p.29;
          ext_op = (int) D.22706;
          p.29 = p;
          p.30 = p.29 + 1;
          p = p.30;
          switch (ext_op) <default: <D.22367>, case 4: <D.22366>, case 5: <D.22365>, case 12: <D.22360>, case 13: <D.22363>, case 14: <D.22362>, case 17: <D.22364>>
          <D.22360>:
          p.29 = p;
          D.22713 = decode_uleb128 (p.29, &p);
          cfa_reg = (int) D.22713;
          p.29 = p;
          D.22714 = decode_uleb128 (p.29, &p);
          cfa_offset = (int) D.22714;
          goto <D.22361>;
          <D.22362>:
          p.29 = p;
          D.22715 = decode_uleb128 (p.29, &p);
          cfa_offset = (int) D.22715;
          goto <D.22361>;
          <D.22363>:
          p.29 = p;
          D.22716 = decode_uleb128 (p.29, &p);
          cfa_reg = (int) D.22716;
          goto <D.22361>;
          <D.22364>:
          p.29 = p;
          D.22717 = decode_uleb128 (p.29, &p);
          reg = (int) D.22717;
          p.29 = p;
          offset = decode_sleb128 (p.29, &p);
          D.22718 = reg > 15;
          D.22719 = (long int) D.22718;
          D.22720 = __builtin_expect (D.22719, 0);
          if (D.22720 != 0) goto <D.22721>; else goto <D.22722>;
          <D.22721>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "unwind.c", 470, "reg < NUM_REGS");
          <D.22722>:
          reg_saved[reg] = 1;
          locations[reg].loc_type = 1;
          D.22723 = offset * -8;
          locations[reg].offset = D.22723;
          goto <D.22361>;
          <D.22365>:
          p.29 = p;
          D.22724 = decode_uleb128 (p.29, &p);
          reg = (int) D.22724;
          p.29 = p;
          D.22725 = decode_uleb128 (p.29, &p);
          offset = (int) D.22725;
          D.22718 = reg > 15;
          D.22719 = (long int) D.22718;
          D.22720 = __builtin_expect (D.22719, 0);
          if (D.22720 != 0) goto <D.22726>; else goto <D.22727>;
          <D.22726>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "unwind.c", 478, "reg < NUM_REGS");
          <D.22727>:
          reg_saved[reg] = 1;
          locations[reg].loc_type = 1;
          D.22723 = offset * -8;
          locations[reg].offset = D.22723;
          goto <D.22361>;
          <D.22366>:
          p.29 = p;
          D.22728 = MEM[(const guint32 *)p.29];
          D.22729 = D.22728 << 24;
          p.29 = p;
          D.22728 = MEM[(const guint32 *)p.29];
          D.22730 = D.22728 >> 8;
          D.22731 = D.22730 & 65280;
          D.22732 = D.22729 | D.22731;
          p.29 = p;
          D.22728 = MEM[(const guint32 *)p.29];
          D.22733 = D.22728 << 8;
          D.22734 = D.22733 & 16711680;
          D.22735 = D.22732 | D.22734;
          p.29 = p;
          D.22728 = MEM[(const guint32 *)p.29];
          D.22736 = D.22728 >> 24;
          D.22737 = D.22735 | D.22736;
          pos.31 = (unsigned int) pos;
          D.22739 = D.22737 + pos.31;
          pos = (int) D.22739;
          p.29 = p;
          p.32 = p.29 + 4;
          p = p.32;
          goto <D.22361>;
          <D.22367>:
          monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "unwind.c", 488);
          <D.22361>:
          goto <D.22356>;
        }
        <D.22368>:
        monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "unwind.c", 493);
        <D.22356>:
      }
      <D.22370>:
      D.22741 = (long int) pos;
      ip.33 = (long int) ip;
      start_ip.34 = (long int) start_ip;
      D.22744 = ip.33 - start_ip.34;
      if (D.22741 <= D.22744) goto <D.22745>; else goto <D.22371>;
      <D.22745>:
      D.22746 = (sizetype) unwind_info_len;
      D.22747 = unwind_info + D.22746;
      p.29 = p;
      if (D.22747 > p.29) goto <D.22369>; else goto <D.22371>;
      <D.22371>:
      if (save_locations != 0B) goto <D.22748>; else goto <D.22749>;
      <D.22748>:
      D.22750 = (long unsigned int) save_locations_len;
      D.22751 = D.22750 * 8;
      memset (save_locations, 0, D.22751);
      <D.22749>:
      D.22752 = (sizetype) cfa_offset;
      D.22753 = mono_dwarf_reg_to_hw_reg (cfa_reg);
      D.22754 = (long unsigned int) D.22753;
      D.22755 = D.22754 * 8;
      D.22756 = regs + D.22755;
      D.22757 = *D.22756;
      D.22758 = (sizetype) D.22757;
      D.22759 = D.22752 + D.22758;
      cfa_val = (guint8 *) D.22759;
      i = 0;
      goto <D.22374>;
      <D.22373>:
      D.22760 = reg_saved[i];
      if (D.22760 != 0) goto <D.22761>; else goto <D.22762>;
      <D.22761>:
      D.22763 = locations[i].loc_type;
      if (D.22763 == 1) goto <D.22764>; else goto <D.22765>;
      <D.22764>:
      {
        int hreg;

        hreg = mono_dwarf_reg_to_hw_reg (i);
        D.22766 = hreg >= nregs;
        D.22767 = (long int) D.22766;
        D.22768 = __builtin_expect (D.22767, 0);
        if (D.22768 != 0) goto <D.22769>; else goto <D.22770>;
        <D.22769>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "unwind.c", 504, "hreg < nregs");
        <D.22770>:
        D.22771 = (long unsigned int) hreg;
        D.22772 = D.22771 * 8;
        D.22773 = regs + D.22772;
        D.22774 = locations[i].offset;
        D.22775 = (sizetype) D.22774;
        D.22776 = cfa_val + D.22775;
        D.22777 = MEM[(mgreg_t *)D.22776];
        *D.22773 = D.22777;
        if (save_locations != 0B) goto <D.22778>; else goto <D.22779>;
        <D.22778>:
        if (hreg < save_locations_len) goto <D.22780>; else goto <D.22781>;
        <D.22780>:
        D.22771 = (long unsigned int) hreg;
        D.22772 = D.22771 * 8;
        D.22782 = save_locations + D.22772;
        D.22774 = locations[i].offset;
        D.22775 = (sizetype) D.22774;
        D.22776 = cfa_val + D.22775;
        *D.22782 = D.22776;
        <D.22781>:
        <D.22779>:
      }
      <D.22765>:
      <D.22762>:
      i = i + 1;
      <D.22374>:
      if (i <= 15) goto <D.22373>; else goto <D.22375>;
      <D.22375>:
      *out_cfa = cfa_val;
    }
  finally
    {
      locations = {CLOBBER};
      reg_saved = {CLOBBER};
      p = {CLOBBER};
    }
}


__attribute__((__artificial__, __gnu_inline__, __always_inline__, __nothrow__, __leaf__))
memset (void * __dest, int __ch, size_t __len)
{
  void * D.22783;
  long unsigned int D.22784;

  D.22784 = __builtin_object_size (__dest, 0);
  D.22783 = __builtin___memset_chk (__dest, __ch, __len, D.22784);
  return D.22783;
}


__attribute__((visibility ("hidden")))
mono_unwind_init ()
{
  InitializeCriticalSection (&unwind_mutex);
  mono_counters_register ("Unwind info size", 256, &unwind_info_size);
}


__attribute__((visibility ("hidden")))
mono_unwind_cleanup ()
{
  struct MonoUnwindInfo * * cached_info.35;
  long unsigned int D.22789;
  long unsigned int D.22790;
  struct MonoUnwindInfo * * D.22791;
  int cached_info_next.36;
  int i;

  DeleteCriticalSection (&unwind_mutex);
  cached_info.35 = cached_info;
  if (cached_info.35 == 0B) goto <D.22787>; else goto <D.22788>;
  <D.22787>:
  return;
  <D.22788>:
  i = 0;
  goto <D.22385>;
  <D.22384>:
  {
    struct MonoUnwindInfo * cached;

    cached_info.35 = cached_info;
    D.22789 = (long unsigned int) i;
    D.22790 = D.22789 * 8;
    D.22791 = cached_info.35 + D.22790;
    cached = *D.22791;
    monoeg_g_free (cached);
  }
  i = i + 1;
  <D.22385>:
  cached_info_next.36 = cached_info_next;
  if (i < cached_info_next.36) goto <D.22384>; else goto <D.22386>;
  <D.22386>:
  cached_info.35 = cached_info;
  monoeg_g_free (cached_info.35);
}


__attribute__((visibility ("hidden")))
mono_cache_unwind_info (guint8 * unwind_info, guint32 unwind_info_len)
{
  _Bool D.22796;
  long int D.22797;
  long int D.22798;
  struct MonoUnwindInfo * * cached_info.37;
  int cached_info_size.38;
  long unsigned int D.22805;
  long unsigned int D.22806;
  void * D.22807;
  long unsigned int D.22808;
  long unsigned int D.22809;
  struct MonoUnwindInfo * * D.22810;
  unsigned int D.22811;
  guint8[0:] * D.22814;
  long unsigned int D.22815;
  int D.22816;
  _Bool D.22821;
  long int D.22822;
  long int D.22823;
  guint32 D.22826;
  int cached_info_next.39;
  long unsigned int D.22828;
  long unsigned int D.22829;
  guint8[0:] * D.22830;
  int D.22833;
  long unsigned int D.22834;
  long unsigned int D.22835;
  struct GSList * cached_info_list.40;
  struct GSList * D.22837;
  int cached_info_next.41;
  int D.22839;
  long unsigned int D.22840;
  long unsigned int D.22841;
  struct MonoUnwindInfo * * D.22842;
  int unwind_info_size.42;
  unsigned int unwind_info_size.43;
  unsigned int D.22845;
  unsigned int D.22846;
  int D.22847;
  _Bool D.22850;
  long int D.22851;
  long int D.22852;
  int i;
  struct MonoUnwindInfo * info;

  {
    int ret;

    ret = pthread_mutex_lock (&unwind_mutex.mutex);
    if (ret != 0) goto <D.22794>; else goto <D.22795>;
    <D.22794>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
    <D.22795>:
    D.22796 = ret != 0;
    D.22797 = (long int) D.22796;
    D.22798 = __builtin_expect (D.22797, 0);
    if (D.22798 != 0) goto <D.22799>; else goto <D.22800>;
    <D.22799>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "unwind.c", 557, "ret == 0");
    <D.22800>:
  }
  cached_info.37 = cached_info;
  if (cached_info.37 == 0B) goto <D.22802>; else goto <D.22803>;
  <D.22802>:
  cached_info_size = 16;
  cached_info_size.38 = cached_info_size;
  D.22805 = (long unsigned int) cached_info_size.38;
  D.22806 = D.22805 * 8;
  D.22807 = monoeg_malloc0 (D.22806);
  cached_info = D.22807;
  <D.22803>:
  i = 0;
  goto <D.22397>;
  <D.22396>:
  {
    struct MonoUnwindInfo * cached;

    cached_info.37 = cached_info;
    D.22808 = (long unsigned int) i;
    D.22809 = D.22808 * 8;
    D.22810 = cached_info.37 + D.22809;
    cached = *D.22810;
    D.22811 = cached->len;
    if (D.22811 == unwind_info_len) goto <D.22812>; else goto <D.22813>;
    <D.22812>:
    D.22814 = &cached->info;
    D.22815 = (long unsigned int) unwind_info_len;
    D.22816 = memcmp (D.22814, unwind_info, D.22815);
    if (D.22816 == 0) goto <D.22817>; else goto <D.22818>;
    <D.22817>:
    {
      int ret;

      ret = pthread_mutex_unlock (&unwind_mutex.mutex);
      if (ret != 0) goto <D.22819>; else goto <D.22820>;
      <D.22819>:
      monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
      <D.22820>:
      D.22821 = ret != 0;
      D.22822 = (long int) D.22821;
      D.22823 = __builtin_expect (D.22822, 0);
      if (D.22823 != 0) goto <D.22824>; else goto <D.22825>;
      <D.22824>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "unwind.c", 568, "ret == 0");
      <D.22825>:
    }
    D.22826 = (guint32) i;
    return D.22826;
    <D.22818>:
    <D.22813>:
  }
  i = i + 1;
  <D.22397>:
  cached_info_next.39 = cached_info_next;
  if (i < cached_info_next.39) goto <D.22396>; else goto <D.22398>;
  <D.22398>:
  D.22828 = (long unsigned int) unwind_info_len;
  D.22829 = D.22828 + 4;
  info = monoeg_malloc (D.22829);
  info->len = unwind_info_len;
  D.22830 = &info->info;
  D.22815 = (long unsigned int) unwind_info_len;
  memcpy (D.22830, unwind_info, D.22815);
  i = cached_info_next;
  cached_info_next.39 = cached_info_next;
  cached_info_size.38 = cached_info_size;
  if (cached_info_next.39 >= cached_info_size.38) goto <D.22831>; else goto <D.22832>;
  <D.22831>:
  {
    struct MonoUnwindInfo * * old_table;
    struct MonoUnwindInfo * * new_table;

    old_table = cached_info;
    cached_info_size.38 = cached_info_size;
    D.22833 = cached_info_size.38 * 2;
    D.22834 = (long unsigned int) D.22833;
    D.22835 = D.22834 * 8;
    new_table = monoeg_malloc0 (D.22835);
    cached_info.37 = cached_info;
    cached_info_size.38 = cached_info_size;
    D.22805 = (long unsigned int) cached_info_size.38;
    D.22806 = D.22805 * 8;
    memcpy (new_table, cached_info.37, D.22806);
    mono_memory_barrier ();
    cached_info = new_table;
    cached_info_list.40 = cached_info_list;
    cached_info.37 = cached_info;
    D.22837 = monoeg_g_slist_prepend (cached_info_list.40, cached_info.37);
    cached_info_list = D.22837;
    cached_info_size.38 = cached_info_size;
    D.22833 = cached_info_size.38 * 2;
    cached_info_size = D.22833;
  }
  <D.22832>:
  cached_info.37 = cached_info;
  cached_info_next.39 = cached_info_next;
  cached_info_next.41 = cached_info_next.39;
  D.22839 = cached_info_next.41 + 1;
  cached_info_next = D.22839;
  D.22840 = (long unsigned int) cached_info_next.41;
  D.22841 = D.22840 * 8;
  D.22842 = cached_info.37 + D.22841;
  *D.22842 = info;
  unwind_info_size.42 = unwind_info_size;
  unwind_info_size.43 = (unsigned int) unwind_info_size.42;
  D.22845 = unwind_info_size.43 + unwind_info_len;
  D.22846 = D.22845 + 4;
  D.22847 = (int) D.22846;
  unwind_info_size = D.22847;
  {
    int ret;

    ret = pthread_mutex_unlock (&unwind_mutex.mutex);
    if (ret != 0) goto <D.22848>; else goto <D.22849>;
    <D.22848>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.22849>:
    D.22850 = ret != 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", "unwind.c", 605, "ret == 0");
    <D.22854>:
  }
  D.22826 = (guint32) i;
  return D.22826;
}


__attribute__((visibility ("hidden")))
mono_get_cached_unwind_info (guint32 index, guint32 * unwind_info_len)
{
  long unsigned int D.22856;
  long unsigned int D.22857;
  struct MonoUnwindInfo * * D.22858;
  unsigned int D.22859;
  guint8 * D.22860;
  struct MonoUnwindInfo * * table;
  struct MonoUnwindInfo * info;
  guint8 * data;

  table = cached_info;
  D.22856 = (long unsigned int) index;
  D.22857 = D.22856 * 8;
  D.22858 = table + D.22857;
  info = *D.22858;
  D.22859 = info->len;
  *unwind_info_len = D.22859;
  data = &info->info;
  D.22860 = data;
  return D.22860;
}


__attribute__((visibility ("hidden")))
mono_unwind_get_dwarf_data_align ()
{
  int D.22862;

  D.22862 = -8;
  return D.22862;
}


__attribute__((visibility ("hidden")))
mono_unwind_get_dwarf_pc_reg ()
{
  int D.22864;

  D.22864 = mono_hw_reg_to_dwarf_reg (14);
  return D.22864;
}


__attribute__((visibility ("hidden")))
mono_unwind_decode_fde (guint8 * fde, guint32 * out_len, guint32 * code_len, struct MonoJitExceptionInfo * * ex_info, guint32 * ex_info_len, void * * * type_info, int * this_reg, int * this_offset)
{
  guint8 * p.44;
  unsigned int D.22867;
  unsigned int fde_len.45;
  unsigned int D.22869;
  _Bool D.22870;
  long int D.22871;
  long int D.22872;
  guint8 * p.46;
  sizetype D.22876;
  sizetype D.22877;
  _Bool D.22878;
  long int D.22879;
  long int D.22880;
  unsigned char D.22883;
  _Bool D.22884;
  long int D.22885;
  long int D.22886;
  guint8 * p.47;
  long unsigned int D.22890;
  long unsigned int D.22891;
  guint8 * p.48;
  unsigned int D.22893;
  unsigned int D.22894;
  char * D.22895;
  unsigned int D.22898;
  sizetype D.22899;
  char * D.22900;
  char D.22901;
  int D.22902;
  unsigned char D.22903;
  _Bool D.22904;
  long int D.22905;
  long int D.22906;
  _Bool D.22909;
  long int D.22910;
  long int D.22911;
  sizetype D.22914;
  guint8 * p.49;
  sizetype D.22916;
  unsigned int D.22919;
  sizetype D.22920;
  guint8 * p.50;
  sizetype D.22923;
  sizetype D.22924;
  guint8 * D.22925;
  long int D.22926;
  long int p.51;
  long int D.22928;
  unsigned int pc_range.52;
  unsigned int D.22938;
  unsigned int D.22939;
  unsigned int D.22940;
  unsigned int D.22941;
  unsigned int D.22942;
  unsigned int D.22943;
  unsigned int D.22944;
  unsigned int D.22945;
  unsigned int D.22946;
  unsigned int D.22947;
  long int D.22951;
  sizetype D.22955;
  _Bool D.22956;
  long int D.22957;
  long int D.22958;
  _Bool D.22961;
  long int D.22962;
  long int D.22963;
  int D.22966;
  _Bool D.22967;
  long int D.22968;
  long int D.22969;
  sizetype D.22972;
  sizetype D.22973;
  guint8 * D.22974;
  long int D.22975;
  long int cie_cfi.53;
  long int D.22977;
  unsigned int D.22978;
  long int fde_cfi.54;
  long int D.22980;
  unsigned int D.22981;
  unsigned int D.22982;
  long unsigned int D.22983;
  guint8 * D.22985;
  long int D.22986;
  long unsigned int D.22987;
  unsigned int D.22988;
  unsigned int i.55;
  unsigned int D.22990;
  long int D.22992;
  long unsigned int D.22993;
  unsigned int D.22994;
  unsigned int D.22995;
  _Bool D.22996;
  long int D.22997;
  long int D.22998;
  unsigned int i.56;
  guint8 * D.23002;
  long unsigned int D.23003;
  guint8 * p;
  guint8 * cie;
  guint8 * fde_current;
  guint8 * fde_aug;
  guint8 * code;
  guint8 * fde_cfi;
  guint8 * cie_cfi;
  gint32 fde_len;
  gint32 cie_offset;
  gint32 pc_begin;
  gint32 pc_range;
  gint32 aug_len;
  gint32 fde_data_len;
  gint32 cie_len;
  gint32 cie_id;
  gint32 cie_version;
  gint32 code_align;
  gint32 data_align;
  gint32 return_reg;
  gint32 i;
  gint32 cie_aug_len;
  gint32 buf_len;
  char * cie_aug_str;
  guint8 * buf;
  gboolean has_fde_augmentation;

  try
    {
      fde_aug = 0B;
      has_fde_augmentation = 0;
      *type_info = 0B;
      *this_reg = -1;
      *this_offset = -1;
      p = fde;
      p.44 = p;
      D.22867 = MEM[(guint32 *)p.44];
      fde_len = (gint32) D.22867;
      fde_len.45 = (unsigned int) fde_len;
      D.22869 = fde_len.45 + 1;
      D.22870 = D.22869 <= 1;
      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", "unwind.c", 833, "fde_len != 0xffffffff && fde_len != 0");
      <D.22874>:
      p.44 = p;
      p.46 = p.44 + 4;
      p = p.46;
      p.44 = p;
      D.22867 = MEM[(guint32 *)p.44];
      cie_offset = (gint32) D.22867;
      p.44 = p;
      D.22876 = (sizetype) cie_offset;
      D.22877 = -D.22876;
      cie = p.44 + D.22877;
      p.44 = p;
      p.46 = p.44 + 4;
      p = p.46;
      fde_current = p;
      p = cie;
      p.44 = p;
      D.22867 = MEM[(guint32 *)p.44];
      cie_len = (gint32) D.22867;
      p.44 = p;
      p.46 = p.44 + 4;
      p = p.46;
      p.44 = p;
      D.22867 = MEM[(guint32 *)p.44];
      cie_id = (gint32) D.22867;
      D.22878 = cie_id != 0;
      D.22879 = (long int) D.22878;
      D.22880 = __builtin_expect (D.22879, 0);
      if (D.22880 != 0) goto <D.22881>; else goto <D.22882>;
      <D.22881>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "unwind.c", 845, "cie_id == 0");
      <D.22882>:
      p.44 = p;
      p.46 = p.44 + 4;
      p = p.46;
      p.44 = p;
      D.22883 = *p.44;
      cie_version = (gint32) D.22883;
      D.22884 = cie_version != 1;
      D.22885 = (long int) D.22884;
      D.22886 = __builtin_expect (D.22885, 0);
      if (D.22886 != 0) goto <D.22887>; else goto <D.22888>;
      <D.22887>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "unwind.c", 848, "cie_version == 1");
      <D.22888>:
      p.44 = p;
      p.47 = p.44 + 1;
      p = p.47;
      cie_aug_str = p;
      D.22890 = __strlen_g (cie_aug_str);
      D.22891 = D.22890 + 1;
      p.44 = p;
      p.48 = p.44 + D.22891;
      p = p.48;
      p.44 = p;
      D.22893 = decode_uleb128 (p.44, &p);
      code_align = (gint32) D.22893;
      p.44 = p;
      data_align = decode_sleb128 (p.44, &p);
      p.44 = p;
      D.22894 = decode_uleb128 (p.44, &p);
      return_reg = (gint32) D.22894;
      D.22895 = __builtin_strchr (cie_aug_str, 122);
      if (D.22895 != 0B) goto <D.22896>; else goto <D.22897>;
      <D.22896>:
      {
        guint8 * cie_aug;
        guint32 p_encoding;

        p.44 = p;
        D.22898 = decode_uleb128 (p.44, &p);
        cie_aug_len = (gint32) D.22898;
        has_fde_augmentation = 1;
        cie_aug = p;
        i = 0;
        goto <D.22512>;
        <D.22511>:
        D.22899 = (sizetype) i;
        D.22900 = cie_aug_str + D.22899;
        D.22901 = *D.22900;
        D.22902 = (int) D.22901;
        switch (D.22902) <default: <D.22510>, case 76: <D.22508>, case 80: <D.22507>, case 82: <D.22509>, case 122: <D.22505>>
        <D.22505>:
        goto <D.22506>;
        <D.22507>:
        p.44 = p;
        D.22883 = *p.44;
        p_encoding = (guint32) D.22883;
        p.44 = p;
        p.47 = p.44 + 1;
        p = p.47;
        p.44 = p;
        read_encoded_val (p_encoding, p.44, &p);
        goto <D.22506>;
        <D.22508>:
        p.44 = p;
        D.22883 = *p.44;
        D.22903 = D.22883 + 229;
        D.22904 = D.22903 > 1;
        D.22905 = (long int) D.22904;
        D.22906 = __builtin_expect (D.22905, 0);
        if (D.22906 != 0) goto <D.22907>; else goto <D.22908>;
        <D.22907>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "unwind.c", 874, "(*p == (DW_EH_PE_sdata4|DW_EH_PE_pcrel)) || (*p == (DW_EH_PE_sdata8|DW_EH_PE_pcrel))");
        <D.22908>:
        p.44 = p;
        p.47 = p.44 + 1;
        p = p.47;
        goto <D.22506>;
        <D.22509>:
        p.44 = p;
        D.22883 = *p.44;
        D.22909 = D.22883 != 27;
        D.22910 = (long int) D.22909;
        D.22911 = __builtin_expect (D.22910, 0);
        if (D.22911 != 0) goto <D.22912>; else goto <D.22913>;
        <D.22912>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "unwind.c", 878, "*p == (DW_EH_PE_sdata4|DW_EH_PE_pcrel)");
        <D.22913>:
        p.44 = p;
        p.47 = p.44 + 1;
        p = p.47;
        goto <D.22506>;
        <D.22510>:
        monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "unwind.c", 882);
        <D.22506>:
        i = i + 1;
        <D.22512>:
        D.22899 = (sizetype) i;
        D.22900 = cie_aug_str + D.22899;
        D.22901 = *D.22900;
        if (D.22901 != 0) goto <D.22511>; else goto <D.22513>;
        <D.22513>:
        p = cie_aug;
        p.44 = p;
        D.22914 = (sizetype) cie_aug_len;
        p.49 = p.44 + D.22914;
        p = p.49;
      }
      <D.22897>:
      cie_cfi = p;
      p = fde_current;
      p.44 = p;
      pc_begin = MEM[(gint32 *)p.44];
      p.44 = p;
      D.22916 = (sizetype) pc_begin;
      code = p.44 + D.22916;
      p.44 = p;
      p.46 = p.44 + 4;
      p = p.46;
      p.44 = p;
      D.22867 = MEM[(guint32 *)p.44];
      pc_range = (gint32) D.22867;
      p.44 = p;
      p.46 = p.44 + 4;
      p = p.46;
      if (has_fde_augmentation != 0) goto <D.22917>; else goto <D.22918>;
      <D.22917>:
      p.44 = p;
      D.22919 = decode_uleb128 (p.44, &p);
      aug_len = (gint32) D.22919;
      fde_aug = p;
      p.44 = p;
      D.22920 = (sizetype) aug_len;
      p.50 = p.44 + D.22920;
      p = p.50;
      goto <D.22922>;
      <D.22918>:
      aug_len = 0;
      <D.22922>:
      fde_cfi = p;
      D.22923 = (sizetype) fde_len;
      D.22924 = D.22923 + 4;
      D.22925 = fde + D.22924;
      D.22926 = (long int) D.22925;
      p.44 = p;
      p.51 = (long int) p.44;
      D.22928 = D.22926 - p.51;
      fde_data_len = (gint32) D.22928;
      if (code_len != 0B) goto <D.22929>; else goto <D.22930>;
      <D.22929>:
      pc_range.52 = (unsigned int) pc_range;
      *code_len = pc_range.52;
      <D.22930>:
      if (ex_info != 0B) goto <D.22932>; else goto <D.22933>;
      <D.22932>:
      *ex_info = 0B;
      *ex_info_len = 0;
      <D.22933>:
      if (aug_len != 0) goto <D.22934>; else goto <D.22935>;
      <D.22934>:
      {
        gint32 lsda_offset;
        guint8 * lsda;

        if (aug_len == 4) goto <D.22936>; else goto <D.22937>;
        <D.22936>:
        D.22938 = MEM[(const guint32 *)fde_aug];
        D.22939 = D.22938 << 24;
        D.22938 = MEM[(const guint32 *)fde_aug];
        D.22940 = D.22938 >> 8;
        D.22941 = D.22940 & 65280;
        D.22942 = D.22939 | D.22941;
        D.22938 = MEM[(const guint32 *)fde_aug];
        D.22943 = D.22938 << 8;
        D.22944 = D.22943 & 16711680;
        D.22945 = D.22942 | D.22944;
        D.22938 = MEM[(const guint32 *)fde_aug];
        D.22946 = D.22938 >> 24;
        D.22947 = D.22945 | D.22946;
        lsda_offset = (gint32) D.22947;
        goto <D.22948>;
        <D.22937>:
        if (aug_len == 8) goto <D.22949>; else goto <D.22950>;
        <D.22949>:
        D.22951 = MEM[(gint64 *)fde_aug];
        lsda_offset = (gint32) D.22951;
        goto <D.22952>;
        <D.22950>:
        monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "unwind.c", 929);
        <D.22952>:
        <D.22948>:
        if (lsda_offset != 0) goto <D.22953>; else goto <D.22954>;
        <D.22953>:
        D.22955 = (sizetype) lsda_offset;
        lsda = fde_aug + D.22955;
        decode_lsda (lsda, code, ex_info, ex_info_len, type_info, this_reg, this_offset);
        <D.22954>:
      }
      <D.22935>:
      D.22956 = code_align != 1;
      D.22957 = (long int) D.22956;
      D.22958 = __builtin_expect (D.22957, 0);
      if (D.22958 != 0) goto <D.22959>; else goto <D.22960>;
      <D.22959>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "unwind.c", 938, "code_align == 1");
      <D.22960>:
      D.22961 = data_align != -8;
      D.22962 = (long int) D.22961;
      D.22963 = __builtin_expect (D.22962, 0);
      if (D.22963 != 0) goto <D.22964>; else goto <D.22965>;
      <D.22964>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "unwind.c", 939, "data_align == DWARF_DATA_ALIGN");
      <D.22965>:
      D.22966 = mono_hw_reg_to_dwarf_reg (14);
      D.22967 = D.22966 != return_reg;
      D.22968 = (long int) D.22967;
      D.22969 = __builtin_expect (D.22968, 0);
      if (D.22969 != 0) goto <D.22970>; else goto <D.22971>;
      <D.22970>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "unwind.c", 940, "return_reg == DWARF_PC_REG");
      <D.22971>:
      D.22972 = (sizetype) cie_len;
      D.22973 = D.22972 + 4;
      D.22974 = cie + D.22973;
      D.22975 = (long int) D.22974;
      cie_cfi.53 = (long int) cie_cfi;
      D.22977 = D.22975 - cie_cfi.53;
      D.22978 = (unsigned int) D.22977;
      D.22923 = (sizetype) fde_len;
      D.22924 = D.22923 + 4;
      D.22925 = fde + D.22924;
      D.22926 = (long int) D.22925;
      fde_cfi.54 = (long int) fde_cfi;
      D.22980 = D.22926 - fde_cfi.54;
      D.22981 = (unsigned int) D.22980;
      D.22982 = D.22978 + D.22981;
      buf_len = (gint32) D.22982;
      D.22983 = (long unsigned int) buf_len;
      buf = monoeg_malloc0 (D.22983);
      i = 0;
      p = cie_cfi;
      goto <D.22518>;
      <D.22517>:
      p.44 = p;
      D.22883 = *p.44;
      if (D.22883 == 0) goto <D.22516>; else goto <D.22984>;
      <D.22984>:
      p.44 = p;
      decode_cie_op (p.44, &p);
      <D.22518>:
      D.22972 = (sizetype) cie_len;
      D.22973 = D.22972 + 4;
      D.22974 = cie + D.22973;
      p.44 = p;
      if (D.22974 > p.44) goto <D.22517>; else goto <D.22516>;
      <D.22516>:
      D.22899 = (sizetype) i;
      D.22985 = buf + D.22899;
      p.44 = p;
      p.51 = (long int) p.44;
      cie_cfi.53 = (long int) cie_cfi;
      D.22986 = p.51 - cie_cfi.53;
      D.22987 = (long unsigned int) D.22986;
      memcpy (D.22985, cie_cfi, D.22987);
      p.44 = p;
      p.51 = (long int) p.44;
      cie_cfi.53 = (long int) cie_cfi;
      D.22986 = p.51 - cie_cfi.53;
      D.22988 = (unsigned int) D.22986;
      i.55 = (unsigned int) i;
      D.22990 = D.22988 + i.55;
      i = (gint32) D.22990;
      p = fde_cfi;
      goto <D.22521>;
      <D.22520>:
      p.44 = p;
      D.22883 = *p.44;
      if (D.22883 == 0) goto <D.22519>; else goto <D.22991>;
      <D.22991>:
      p.44 = p;
      decode_cie_op (p.44, &p);
      <D.22521>:
      D.22923 = (sizetype) fde_len;
      D.22924 = D.22923 + 4;
      D.22925 = fde + D.22924;
      p.44 = p;
      if (D.22925 > p.44) goto <D.22520>; else goto <D.22519>;
      <D.22519>:
      D.22899 = (sizetype) i;
      D.22985 = buf + D.22899;
      p.44 = p;
      p.51 = (long int) p.44;
      fde_cfi.54 = (long int) fde_cfi;
      D.22992 = p.51 - fde_cfi.54;
      D.22993 = (long unsigned int) D.22992;
      memcpy (D.22985, fde_cfi, D.22993);
      p.44 = p;
      p.51 = (long int) p.44;
      fde_cfi.54 = (long int) fde_cfi;
      D.22992 = p.51 - fde_cfi.54;
      D.22994 = (unsigned int) D.22992;
      i.55 = (unsigned int) i;
      D.22995 = D.22994 + i.55;
      i = (gint32) D.22995;
      D.22996 = i > buf_len;
      D.22997 = (long int) D.22996;
      D.22998 = __builtin_expect (D.22997, 0);
      if (D.22998 != 0) goto <D.22999>; else goto <D.23000>;
      <D.22999>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "unwind.c", 965, "i <= buf_len");
      <D.23000>:
      i.56 = (unsigned int) i;
      *out_len = i.56;
      D.23003 = (long unsigned int) i;
      D.23002 = monoeg_realloc (buf, D.23003);
      return D.23002;
    }
  finally
    {
      p = {CLOBBER};
    }
}


__attribute__((__gnu_inline__))
__strlen_g (const char * __str)
{
  size_t D.23007;
  long int __ptr.57;
  long int __str.58;
  long int D.23010;
  char * __ptr;
  char * __tmp;

  __ptr = 0B;
  __tmp = __str;
  __asm__ __volatile__("   la    0,0
0: srst  %0,%1
   jo    0b
" : "=&a" __ptr, "=&a" __tmp : "0" __ptr, "1" __tmp : "0", "memory", "cc");
  __ptr.57 = (long int) __ptr;
  __str.58 = (long int) __str;
  D.23010 = __ptr.57 - __str.58;
  D.23007 = (size_t) D.23010;
  return D.23007;
}


read_encoded_val (guint32 encoding, guint8 * p, guint8 * * endp)
{
  unsigned int D.23012;
  int D.23013;
  gint64 D.23014;
  gint64 res;

  D.23012 = encoding & 15;
  switch (D.23012) <default: <D.22442>, case 11: <D.22441>, case 12: <D.22439>>
  <D.22439>:
  res = MEM[(gint64 *)p];
  p = p + 8;
  goto <D.22440>;
  <D.22441>:
  D.23013 = MEM[(gint32 *)p];
  res = (gint64) D.23013;
  p = p + 4;
  goto <D.22440>;
  <D.22442>:
  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "unwind.c", 717);
  <D.22440>:
  *endp = p;
  D.23014 = res;
  return D.23014;
}


decode_lsda (guint8 * lsda, guint8 * code, struct MonoJitExceptionInfo * * ex_info, guint32 * ex_info_len, void * * * type_info, int * this_reg, int * this_offset)
{
  guint8 * p.59;
  _Bool D.23017;
  long int D.23018;
  long int D.23019;
  _Bool D.23022;
  long int D.23023;
  long int D.23024;
  unsigned char D.23027;
  guint8 * p.60;
  _Bool D.23031;
  long int D.23032;
  long int D.23033;
  unsigned int D.23036;
  int D.23037;
  _Bool D.23039;
  long int D.23040;
  long int D.23041;
  unsigned int D.23044;
  long unsigned int p.61;
  long unsigned int D.23046;
  long unsigned int D.23047;
  guint8 * p.62;
  long unsigned int D.23051;
  long unsigned int D.23052;
  void * D.23053;
  unsigned int ncall_sites.63;
  long unsigned int D.23057;
  void * D.23058;
  unsigned int D.23059;
  unsigned int D.23060;
  unsigned int D.23061;
  unsigned int D.23062;
  unsigned int D.23063;
  unsigned int D.23064;
  unsigned int D.23065;
  unsigned int D.23066;
  unsigned int D.23067;
  unsigned int D.23068;
  guint8 * p.64;
  _Bool D.23070;
  long int D.23071;
  long int D.23072;
  long unsigned int tinfo.65;
  long unsigned int D.23076;
  _Bool D.23077;
  long int D.23078;
  long int D.23079;
  void * * D.23084;
  long unsigned int D.23087;
  long unsigned int D.23088;
  void * * D.23089;
  struct MonoJitExceptionInfo * D.23090;
  long unsigned int D.23091;
  struct MonoJitExceptionInfo * D.23092;
  sizetype D.23093;
  guint8 * D.23094;
  sizetype D.23095;
  sizetype D.23096;
  guint8 * D.23097;
  sizetype D.23098;
  guint8 * D.23099;
  guint8 * p;
  int i;
  int ncall_sites;
  int this_encoding;
  guint32 mono_magic;
  guint32 version;

  try
    {
      p = lsda;
      p.59 = p;
      mono_magic = decode_uleb128 (p.59, &p);
      D.23017 = mono_magic != 1297084239;
      D.23018 = (long int) D.23017;
      D.23019 = __builtin_expect (D.23018, 0);
      if (D.23019 != 0) goto <D.23020>; else goto <D.23021>;
      <D.23020>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "unwind.c", 740, "mono_magic == 0x4d4fef4f");
      <D.23021>:
      p.59 = p;
      version = decode_uleb128 (p.59, &p);
      D.23022 = version != 1;
      D.23023 = (long int) D.23022;
      D.23024 = __builtin_expect (D.23023, 0);
      if (D.23024 != 0) goto <D.23025>; else goto <D.23026>;
      <D.23025>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "unwind.c", 742, "version == 1");
      <D.23026>:
      p.59 = p;
      D.23027 = *p.59;
      this_encoding = (int) D.23027;
      p.59 = p;
      p.60 = p.59 + 1;
      p = p.60;
      if (this_encoding == 3) goto <D.23029>; else goto <D.23030>;
      <D.23029>:
      {
        gint32 op;
        gint32 reg;
        gint32 offset;

        p.59 = p;
        D.23027 = *p.59;
        op = (gint32) D.23027;
        D.23031 = op != 146;
        D.23032 = (long int) D.23031;
        D.23033 = __builtin_expect (D.23032, 0);
        if (D.23033 != 0) goto <D.23034>; else goto <D.23035>;
        <D.23034>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "unwind.c", 750, "op == DW_OP_bregx");
        <D.23035>:
        p.59 = p;
        p.60 = p.59 + 1;
        p = p.60;
        p.59 = p;
        D.23036 = decode_uleb128 (p.59, &p);
        reg = (gint32) D.23036;
        p.59 = p;
        offset = decode_sleb128 (p.59, &p);
        D.23037 = mono_dwarf_reg_to_hw_reg (reg);
        *this_reg = D.23037;
        *this_offset = offset;
      }
      goto <D.23038>;
      <D.23030>:
      D.23039 = this_encoding != 255;
      D.23040 = (long int) D.23039;
      D.23041 = __builtin_expect (D.23040, 0);
      if (D.23041 != 0) goto <D.23042>; else goto <D.23043>;
      <D.23042>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "unwind.c", 758, "this_encoding == DW_EH_PE_omit");
      <D.23043>:
      *this_reg = -1;
      *this_offset = -1;
      <D.23038>:
      p.59 = p;
      D.23044 = decode_uleb128 (p.59, &p);
      ncall_sites = (int) D.23044;
      p.59 = p;
      p.61 = (long unsigned int) p.59;
      D.23046 = p.61 + 3;
      D.23047 = D.23046 & 18446744073709551612;
      p.62 = (guint8 *) D.23047;
      p = p.62;
      if (ex_info != 0B) goto <D.23049>; else goto <D.23050>;
      <D.23049>:
      D.23051 = (long unsigned int) ncall_sites;
      D.23052 = D.23051 * 40;
      D.23053 = monoeg_malloc0 (D.23052);
      *ex_info = D.23053;
      ncall_sites.63 = (unsigned int) ncall_sites;
      *ex_info_len = ncall_sites.63;
      <D.23050>:
      if (type_info != 0B) goto <D.23055>; else goto <D.23056>;
      <D.23055>:
      D.23051 = (long unsigned int) ncall_sites;
      D.23057 = D.23051 * 8;
      D.23058 = monoeg_malloc0 (D.23057);
      *type_info = D.23058;
      <D.23056>:
      i = 0;
      goto <D.22466>;
      <D.22465>:
      {
        int block_start_offset;
        int block_size;
        int landing_pad;
        guint8 * tinfo;

        p.59 = p;
        D.23059 = MEM[(const guint32 *)p.59];
        D.23060 = D.23059 << 24;
        p.59 = p;
        D.23059 = MEM[(const guint32 *)p.59];
        D.23061 = D.23059 >> 8;
        D.23062 = D.23061 & 65280;
        D.23063 = D.23060 | D.23062;
        p.59 = p;
        D.23059 = MEM[(const guint32 *)p.59];
        D.23064 = D.23059 << 8;
        D.23065 = D.23064 & 16711680;
        D.23066 = D.23063 | D.23065;
        p.59 = p;
        D.23059 = MEM[(const guint32 *)p.59];
        D.23067 = D.23059 >> 24;
        D.23068 = D.23066 | D.23067;
        block_start_offset = (int) D.23068;
        p.59 = p;
        p.64 = p.59 + 4;
        p = p.64;
        p.59 = p;
        D.23059 = MEM[(const guint32 *)p.59];
        D.23060 = D.23059 << 24;
        p.59 = p;
        D.23059 = MEM[(const guint32 *)p.59];
        D.23061 = D.23059 >> 8;
        D.23062 = D.23061 & 65280;
        D.23063 = D.23060 | D.23062;
        p.59 = p;
        D.23059 = MEM[(const guint32 *)p.59];
        D.23064 = D.23059 << 8;
        D.23065 = D.23064 & 16711680;
        D.23066 = D.23063 | D.23065;
        p.59 = p;
        D.23059 = MEM[(const guint32 *)p.59];
        D.23067 = D.23059 >> 24;
        D.23068 = D.23066 | D.23067;
        block_size = (int) D.23068;
        p.59 = p;
        p.64 = p.59 + 4;
        p = p.64;
        p.59 = p;
        D.23059 = MEM[(const guint32 *)p.59];
        D.23060 = D.23059 << 24;
        p.59 = p;
        D.23059 = MEM[(const guint32 *)p.59];
        D.23061 = D.23059 >> 8;
        D.23062 = D.23061 & 65280;
        D.23063 = D.23060 | D.23062;
        p.59 = p;
        D.23059 = MEM[(const guint32 *)p.59];
        D.23064 = D.23059 << 8;
        D.23065 = D.23064 & 16711680;
        D.23066 = D.23063 | D.23065;
        p.59 = p;
        D.23059 = MEM[(const guint32 *)p.59];
        D.23067 = D.23059 >> 24;
        D.23068 = D.23066 | D.23067;
        landing_pad = (int) D.23068;
        p.59 = p;
        p.64 = p.59 + 4;
        p = p.64;
        tinfo = p;
        p.59 = p;
        p.64 = p.59 + 4;
        p = p.64;
        D.23070 = landing_pad == 0;
        D.23071 = (long int) D.23070;
        D.23072 = __builtin_expect (D.23071, 0);
        if (D.23072 != 0) goto <D.23073>; else goto <D.23074>;
        <D.23073>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "unwind.c", 786, "landing_pad");
        <D.23074>:
        tinfo.65 = (long unsigned int) tinfo;
        D.23076 = tinfo.65 & 3;
        D.23077 = D.23076 != 0;
        D.23078 = (long int) D.23077;
        D.23079 = __builtin_expect (D.23078, 0);
        if (D.23079 != 0) goto <D.23080>; else goto <D.23081>;
        <D.23080>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "unwind.c", 787, "((size_t)tinfo % 4) == 0");
        <D.23081>:
        if (ex_info != 0B) goto <D.23082>; else goto <D.23083>;
        <D.23082>:
        D.23084 = *type_info;
        if (D.23084 != 0B) goto <D.23085>; else goto <D.23086>;
        <D.23085>:
        D.23084 = *type_info;
        D.23087 = (long unsigned int) i;
        D.23088 = D.23087 * 8;
        D.23089 = D.23084 + D.23088;
        *D.23089 = tinfo;
        <D.23086>:
        D.23090 = *ex_info;
        D.23087 = (long unsigned int) i;
        D.23091 = D.23087 * 40;
        D.23092 = D.23090 + D.23091;
        D.23093 = (sizetype) block_start_offset;
        D.23094 = code + D.23093;
        D.23092->try_start = D.23094;
        D.23090 = *ex_info;
        D.23087 = (long unsigned int) i;
        D.23091 = D.23087 * 40;
        D.23092 = D.23090 + D.23091;
        D.23093 = (sizetype) block_start_offset;
        D.23095 = (sizetype) block_size;
        D.23096 = D.23093 + D.23095;
        D.23097 = code + D.23096;
        D.23092->try_end = D.23097;
        D.23090 = *ex_info;
        D.23087 = (long unsigned int) i;
        D.23091 = D.23087 * 40;
        D.23092 = D.23090 + D.23091;
        D.23098 = (sizetype) landing_pad;
        D.23099 = code + D.23098;
        D.23092->handler_start = D.23099;
        <D.23083>:
      }
      i = i + 1;
      <D.22466>:
      if (i < ncall_sites) goto <D.22465>; else goto <D.22467>;
      <D.22467>:
    }
  finally
    {
      p = {CLOBBER};
    }
}


decode_cie_op (guint8 * p, guint8 * * endp)
{
  guint8 * p.66;
  unsigned char D.23101;
  int D.23102;
  guint8 * p.67;
  guint8 * p.68;
  int op;

  p.66 = p;
  D.23101 = *p.66;
  D.23102 = (int) D.23101;
  op = D.23102 & 192;
  switch (op) <default: <D.22432>, case 0: <D.22423>, case 64: <D.22420>, case 128: <D.22422>>
  <D.22420>:
  p.66 = p;
  p.67 = p.66 + 1;
  p = p.67;
  goto <D.22421>;
  <D.22422>:
  p.66 = p;
  p.67 = p.66 + 1;
  p = p.67;
  p.66 = p;
  decode_uleb128 (p.66, &p);
  goto <D.22421>;
  <D.22423>:
  {
    int ext_op;

    p.66 = p;
    D.23101 = *p.66;
    ext_op = (int) D.23101;
    p.66 = p;
    p.67 = p.66 + 1;
    p = p.67;
    switch (ext_op) <default: <D.22431>, case 4: <D.22429>, case 12: <D.22425>, case 13: <D.22428>, case 14: <D.22427>, case 17: <D.22430>>
    <D.22425>:
    p.66 = p;
    decode_uleb128 (p.66, &p);
    p.66 = p;
    decode_uleb128 (p.66, &p);
    goto <D.22426>;
    <D.22427>:
    p.66 = p;
    decode_uleb128 (p.66, &p);
    goto <D.22426>;
    <D.22428>:
    p.66 = p;
    decode_uleb128 (p.66, &p);
    goto <D.22426>;
    <D.22429>:
    p.66 = p;
    p.68 = p.66 + 4;
    p = p.68;
    goto <D.22426>;
    <D.22430>:
    p.66 = p;
    decode_uleb128 (p.66, &p);
    p.66 = p;
    decode_uleb128 (p.66, &p);
    goto <D.22426>;
    <D.22431>:
    monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "unwind.c", 691);
    <D.22426>:
    goto <D.22421>;
  }
  <D.22432>:
  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "unwind.c", 696);
  <D.22421>:
  p.66 = p;
  *endp = p.66;
}


__attribute__((visibility ("hidden")))
mono_unwind_decode_llvm_mono_fde (guint8 * fde, int fde_len, guint8 * cie, guint8 * code, struct MonoLLVMFDEInfo * res)
{
  guint8 * p.69;
  unsigned char D.23106;
  guint8 * p.70;
  unsigned int D.23110;
  unsigned int D.23111;
  unsigned int D.23112;
  unsigned int D.23113;
  unsigned int D.23114;
  unsigned int D.23115;
  unsigned int D.23116;
  unsigned int D.23117;
  unsigned int D.23118;
  unsigned int D.23119;
  guint8 * p.71;
  sizetype D.23122;
  guint8 * p.72;
  struct MonoJitExceptionInfo * * D.23126;
  guint32 * D.23127;
  void * * * D.23128;
  int * D.23129;
  int * D.23130;
  unsigned int D.23131;
  unsigned int D.23132;
  unsigned int pers_encoding.73;
  _Bool D.23136;
  long int D.23137;
  long int D.23138;
  _Bool D.23141;
  long int D.23142;
  long int D.23143;
  int D.23146;
  _Bool D.23147;
  long int D.23148;
  long int D.23149;
  long int p.74;
  long int cie_cfi.75;
  long int D.23155;
  sizetype D.23156;
  guint8 * D.23157;
  long int D.23158;
  long int fde_cfi.76;
  long int D.23160;
  int D.23161;
  long unsigned int D.23162;
  long unsigned int D.23163;
  sizetype D.23164;
  guint8 * D.23165;
  long unsigned int D.23166;
  unsigned int D.23167;
  guint8 * p;
  guint8 * fde_aug;
  guint8 * cie_cfi;
  guint8 * fde_cfi;
  guint8 * buf;
  int has_aug;
  int aug_len;
  int cie_cfi_len;
  int fde_cfi_len;
  gint32 code_align;
  gint32 data_align;
  gint32 return_reg;
  gint32 pers_encoding;

  try
    {
      memset (res, 0, 48);
      res->this_reg = -1;
      res->this_offset = -1;
      p = fde;
      p.69 = p;
      D.23106 = *p.69;
      has_aug = (int) D.23106;
      p.69 = p;
      p.70 = p.69 + 1;
      p = p.70;
      if (has_aug != 0) goto <D.23108>; else goto <D.23109>;
      <D.23108>:
      p.69 = p;
      D.23110 = MEM[(const guint32 *)p.69];
      D.23111 = D.23110 << 24;
      p.69 = p;
      D.23110 = MEM[(const guint32 *)p.69];
      D.23112 = D.23110 >> 8;
      D.23113 = D.23112 & 65280;
      D.23114 = D.23111 | D.23113;
      p.69 = p;
      D.23110 = MEM[(const guint32 *)p.69];
      D.23115 = D.23110 << 8;
      D.23116 = D.23115 & 16711680;
      D.23117 = D.23114 | D.23116;
      p.69 = p;
      D.23110 = MEM[(const guint32 *)p.69];
      D.23118 = D.23110 >> 24;
      D.23119 = D.23117 | D.23118;
      aug_len = (int) D.23119;
      p.69 = p;
      p.71 = p.69 + 4;
      p = p.71;
      goto <D.23121>;
      <D.23109>:
      aug_len = 0;
      <D.23121>:
      fde_aug = p;
      p.69 = p;
      D.23122 = (sizetype) aug_len;
      p.72 = p.69 + D.23122;
      p = p.72;
      fde_cfi = p;
      if (has_aug != 0) goto <D.23124>; else goto <D.23125>;
      <D.23124>:
      {
        guint8 * lsda;

        lsda = fde_aug;
        D.23126 = &res->ex_info;
        D.23127 = &res->ex_info_len;
        D.23128 = &res->type_info;
        D.23129 = &res->this_reg;
        D.23130 = &res->this_offset;
        decode_lsda (lsda, code, D.23126, D.23127, D.23128, D.23129, D.23130);
      }
      <D.23125>:
      p = cie;
      p.69 = p;
      D.23131 = decode_uleb128 (p.69, &p);
      code_align = (gint32) D.23131;
      p.69 = p;
      data_align = decode_sleb128 (p.69, &p);
      p.69 = p;
      D.23132 = decode_uleb128 (p.69, &p);
      return_reg = (gint32) D.23132;
      p.69 = p;
      D.23106 = *p.69;
      pers_encoding = (gint32) D.23106;
      p.69 = p;
      p.70 = p.69 + 1;
      p = p.70;
      if (pers_encoding != 255) goto <D.23133>; else goto <D.23134>;
      <D.23133>:
      pers_encoding.73 = (unsigned int) pers_encoding;
      p.69 = p;
      read_encoded_val (pers_encoding.73, p.69, &p);
      <D.23134>:
      cie_cfi = p;
      D.23136 = code_align != 1;
      D.23137 = (long int) D.23136;
      D.23138 = __builtin_expect (D.23137, 0);
      if (D.23138 != 0) goto <D.23139>; else goto <D.23140>;
      <D.23139>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "unwind.c", 1028, "code_align == 1");
      <D.23140>:
      D.23141 = data_align != -8;
      D.23142 = (long int) D.23141;
      D.23143 = __builtin_expect (D.23142, 0);
      if (D.23143 != 0) goto <D.23144>; else goto <D.23145>;
      <D.23144>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "unwind.c", 1029, "data_align == DWARF_DATA_ALIGN");
      <D.23145>:
      D.23146 = mono_hw_reg_to_dwarf_reg (14);
      D.23147 = D.23146 != return_reg;
      D.23148 = (long int) D.23147;
      D.23149 = __builtin_expect (D.23148, 0);
      if (D.23149 != 0) goto <D.23150>; else goto <D.23151>;
      <D.23150>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "unwind.c", 1030, "return_reg == DWARF_PC_REG");
      <D.23151>:
      p = cie_cfi;
      <D.22544>:
      p.69 = p;
      D.23106 = *p.69;
      if (D.23106 == 0) goto <D.22543>; else goto <D.23152>;
      <D.23152>:
      p.69 = p;
      decode_cie_op (p.69, &p);
      goto <D.22544>;
      <D.22543>:
      p.69 = p;
      p.74 = (long int) p.69;
      cie_cfi.75 = (long int) cie_cfi;
      D.23155 = p.74 - cie_cfi.75;
      cie_cfi_len = (int) D.23155;
      D.23156 = (sizetype) fde_len;
      D.23157 = fde + D.23156;
      D.23158 = (long int) D.23157;
      fde_cfi.76 = (long int) fde_cfi;
      D.23160 = D.23158 - fde_cfi.76;
      fde_cfi_len = (int) D.23160;
      D.23161 = cie_cfi_len + fde_cfi_len;
      D.23162 = (long unsigned int) D.23161;
      buf = monoeg_malloc0 (D.23162);
      D.23163 = (long unsigned int) cie_cfi_len;
      memcpy (buf, cie_cfi, D.23163);
      D.23164 = (sizetype) cie_cfi_len;
      D.23165 = buf + D.23164;
      D.23166 = (long unsigned int) fde_cfi_len;
      memcpy (D.23165, fde_cfi, D.23166);
      D.23161 = cie_cfi_len + fde_cfi_len;
      D.23167 = (unsigned int) D.23161;
      res->unw_info_len = D.23167;
      res->unw_info = buf;
    }
  finally
    {
      p = {CLOBBER};
    }
}


__attribute__((visibility ("hidden")))
mono_unwind_get_cie_program ()
{
  struct GSList * D.23168;

  D.23168 = 0B;
  return D.23168;
}