mono_hw_reg_to_dwarf_reg (int reg)
{
  int D.22631;

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


mono_dwarf_reg_to_hw_reg (int reg)
{
  int dwarf_reg_to_hw_reg_inited.0;
  int D.22636;

  dwarf_reg_to_hw_reg_inited.0 = dwarf_reg_to_hw_reg_inited;
  if (dwarf_reg_to_hw_reg_inited.0 == 0) goto <D.22634>; else goto <D.22635>;
  <D.22634>:
  init_reg_map ();
  <D.22635>:
  D.22636 = map_dwarf_reg_to_hw_reg[reg];
  return D.22636;
}


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

  if (0 != 0) goto <D.22638>; else goto <D.22639>;
  <D.22638>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "unwind.c", 138, "NUM_REGS > 0");
  <D.22639>:
  i = 0;
  goto <D.22303>;
  <D.22302>:
  D.22640 = mono_hw_reg_to_dwarf_reg (i);
  map_dwarf_reg_to_hw_reg[D.22640] = i;
  i = i + 1;
  <D.22303>:
  i.1 = (unsigned int) i;
  if (i.1 <= 16) goto <D.22302>; else goto <D.22304>;
  <D.22304>:
  mono_memory_barrier ();
  dwarf_reg_to_hw_reg_inited = 1;
}


mono_memory_barrier ()
{
  __sync_synchronize ();
}


mono_print_unwind_info (guint8 * unwind_info, int unwind_info_len)
{
  guint8 * p.2;
  unsigned char D.22643;
  int D.22644;
  int D.22645;
  guint8 * p.3;
  unsigned int D.22647;
  unsigned int D.22648;
  int D.22649;
  int D.22652;
  int D.22654;
  const char * D.22655;
  unsigned int D.22656;
  unsigned int D.22657;
  int D.22658;
  const char * D.22659;
  unsigned int D.22660;
  unsigned int D.22661;
  int D.22662;
  const char * D.22663;
  unsigned int D.22664;
  int D.22665;
  int D.22666;
  const char * D.22667;
  unsigned int D.22668;
  unsigned int pos.4;
  unsigned int D.22670;
  guint8 * p.5;
  sizetype D.22672;
  guint8 * D.22673;
  guint8 * p;
  int pos;
  int reg;
  int offset;
  int cfa_reg;
  int cfa_offset;

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

        p.2 = p;
        D.22643 = *p.2;
        D.22644 = (int) D.22643;
        op = D.22644 & 192;
        switch (op) <default: <D.22373>, case 0: <D.22364>, case 64: <D.22361>, case 128: <D.22363>>
        <D.22361>:
        p.2 = p;
        D.22643 = *p.2;
        D.22644 = (int) D.22643;
        D.22645 = D.22644 & 63;
        pos = D.22645 + pos;
        p.2 = p;
        p.3 = p.2 + 1;
        p = p.3;
        goto <D.22362>;
        <D.22363>:
        p.2 = p;
        D.22643 = *p.2;
        D.22644 = (int) D.22643;
        reg = D.22644 & 63;
        p.2 = p;
        p.3 = p.2 + 1;
        p = p.3;
        p.2 = p;
        D.22647 = decode_uleb128 (p.2, &p);
        D.22648 = D.22647 * 4294967288;
        offset = (int) D.22648;
        D.22649 = mono_hw_reg_to_dwarf_reg (16);
        if (D.22649 == reg) goto <D.22650>; else goto <D.22651>;
        <D.22650>:
        D.22652 = -offset;
        printf ("CFA: [%x] offset: %s at cfa-0x%x\n", pos, "pc", D.22652);
        goto <D.22653>;
        <D.22651>:
        D.22652 = -offset;
        D.22654 = mono_dwarf_reg_to_hw_reg (reg);
        D.22655 = mono_arch_regname (D.22654);
        printf ("CFA: [%x] offset: %s at cfa-0x%x\n", pos, D.22655, D.22652);
        <D.22653>:
        goto <D.22362>;
        <D.22364>:
        {
          int ext_op;

          p.2 = p;
          D.22643 = *p.2;
          ext_op = (int) D.22643;
          p.2 = p;
          p.3 = p.2 + 1;
          p = p.3;
          switch (ext_op) <default: <D.22372>, case 4: <D.22371>, case 12: <D.22366>, case 13: <D.22369>, case 14: <D.22368>, case 17: <D.22370>>
          <D.22366>:
          p.2 = p;
          D.22656 = decode_uleb128 (p.2, &p);
          cfa_reg = (int) D.22656;
          p.2 = p;
          D.22657 = decode_uleb128 (p.2, &p);
          cfa_offset = (int) D.22657;
          D.22658 = mono_dwarf_reg_to_hw_reg (cfa_reg);
          D.22659 = mono_arch_regname (D.22658);
          printf ("CFA: [%x] def_cfa: %s+0x%x\n", pos, D.22659, cfa_offset);
          goto <D.22367>;
          <D.22368>:
          p.2 = p;
          D.22660 = decode_uleb128 (p.2, &p);
          cfa_offset = (int) D.22660;
          printf ("CFA: [%x] def_cfa_offset: 0x%x\n", pos, cfa_offset);
          goto <D.22367>;
          <D.22369>:
          p.2 = p;
          D.22661 = decode_uleb128 (p.2, &p);
          cfa_reg = (int) D.22661;
          D.22662 = mono_dwarf_reg_to_hw_reg (cfa_reg);
          D.22663 = mono_arch_regname (D.22662);
          printf ("CFA: [%x] def_cfa_reg: %s\n", pos, D.22663);
          goto <D.22367>;
          <D.22370>:
          p.2 = p;
          D.22664 = decode_uleb128 (p.2, &p);
          reg = (int) D.22664;
          p.2 = p;
          D.22665 = decode_sleb128 (p.2, &p);
          offset = D.22665 * -8;
          D.22652 = -offset;
          D.22666 = mono_dwarf_reg_to_hw_reg (reg);
          D.22667 = mono_arch_regname (D.22666);
          printf ("CFA: [%x] offset_extended_sf: %s at cfa-0x%x\n", pos, D.22667, D.22652);
          goto <D.22367>;
          <D.22371>:
          p.2 = p;
          D.22668 = MEM[(const guint32 *)p.2];
          pos.4 = (unsigned int) pos;
          D.22670 = D.22668 + pos.4;
          pos = (int) D.22670;
          p.2 = p;
          p.5 = p.2 + 4;
          p = p.5;
          goto <D.22367>;
          <D.22372>:
          monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "unwind.c", 306);
          <D.22367>:
          goto <D.22362>;
        }
        <D.22373>:
        monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "unwind.c", 311);
        <D.22362>:
      }
      <D.22375>:
      D.22672 = (sizetype) unwind_info_len;
      D.22673 = unwind_info + D.22672;
      p.2 = p;
      if (D.22673 > p.2) goto <D.22374>; else goto <D.22376>;
      <D.22376>:
    }
  finally
    {
      p = {CLOBBER};
    }
}


decode_uleb128 (guint8 * buf, guint8 * * endbuf)
{
  int D.22674;
  int D.22675;
  int D.22676;
  unsigned int D.22677;
  signed char b.6;
  guint32 D.22680;
  guint8 * p;
  guint32 res;
  int shift;

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

    b = *p;
    p = p + 1;
    D.22674 = (int) b;
    D.22675 = D.22674 & 127;
    D.22676 = D.22675 << shift;
    D.22677 = (unsigned int) D.22676;
    res = D.22677 | res;
    b.6 = (signed char) b;
    if (b.6 >= 0) goto <D.22338>; else goto <D.22679>;
    <D.22679>:
    shift = shift + 7;
  }
  goto <D.22339>;
  <D.22338>:
  *endbuf = p;
  D.22680 = res;
  return D.22680;
}


decode_sleb128 (guint8 * buf, guint8 * * endbuf)
{
  int D.22682;
  int D.22683;
  int D.22684;
  signed char b.7;
  int D.22690;
  int D.22693;
  int D.22694;
  gint32 D.22695;
  guint8 * p;
  gint32 res;
  int shift;

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

    b = *p;
    p = p + 1;
    D.22682 = (int) b;
    D.22683 = D.22682 & 127;
    D.22684 = D.22683 << shift;
    res = D.22684 | res;
    shift = shift + 7;
    b.7 = (signed char) b;
    if (b.7 >= 0) goto <D.22686>; else goto <D.22687>;
    <D.22686>:
    if (shift <= 31) goto <D.22688>; else goto <D.22689>;
    <D.22688>:
    D.22682 = (int) b;
    D.22690 = D.22682 & 64;
    if (D.22690 != 0) goto <D.22691>; else goto <D.22692>;
    <D.22691>:
    D.22693 = 1 << shift;
    D.22694 = -D.22693;
    res = D.22694 | res;
    <D.22692>:
    <D.22689>:
    goto <D.22348>;
    <D.22687>:
  }
  goto <D.22349>;
  <D.22348>:
  *endbuf = p;
  D.22695 = res;
  return D.22695;
}


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

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


mono_unwind_ops_encode (struct GSList * unwind_ops, guint32 * out_len)
{
  short unsigned int D.22699;
  int D.22700;
  unsigned int D.22701;
  unsigned int loc.8;
  unsigned int D.22703;
  guint8 * p.9;
  guint8 * p.10;
  guint8 * p.11;
  unsigned char D.22709;
  unsigned char D.22710;
  unsigned char D.22711;
  unsigned char D.22712;
  guint8 * p.12;
  guint8 * p.13;
  unsigned char D.22716;
  int D.22717;
  guint8 * p.14;
  guint8 * p.15;
  unsigned int reg.16;
  int D.22721;
  unsigned int D.22722;
  guint8 * p.17;
  guint8 * p.18;
  guint8 * p.19;
  guint8 * p.20;
  guint8 * p.21;
  guint8 * p.22;
  int D.22731;
  guint8 * p.23;
  guint8 * p.24;
  signed char D.22735;
  signed char D.22736;
  unsigned char D.22737;
  unsigned int D.22738;
  long int p.25;
  long int buf.26;
  long int D.22741;
  _Bool D.22742;
  long int D.22743;
  long int D.22744;
  unsigned int D.22747;
  long unsigned int D.22748;
  long unsigned int D.22749;
  guint8 * D.22750;
  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.22398>;
      <D.22397>:
      {
        int reg;

        op = l->data;
        D.22699 = op->reg;
        D.22700 = (int) D.22699;
        reg = mono_hw_reg_to_dwarf_reg (D.22700);
        goto <D.22389>;
        <D.22388>:
        D.22701 = op->when;
        loc.8 = (unsigned int) loc;
        D.22703 = D.22701 - loc.8;
        if (D.22703 <= 31) goto <D.22704>; else goto <D.22705>;
        <D.22704>:
        p.9 = p;
        p.10 = p.9;
        p.11 = p.10 + 1;
        p = p.11;
        D.22701 = op->when;
        D.22709 = (unsigned char) D.22701;
        D.22710 = (unsigned char) loc;
        D.22711 = D.22709 - D.22710;
        D.22712 = D.22711 | 64;
        *p.10 = D.22712;
        D.22701 = op->when;
        loc = (int) D.22701;
        goto <D.22713>;
        <D.22705>:
        p.9 = p;
        p.12 = p.9;
        p.13 = p.12 + 1;
        p = p.13;
        *p.12 = 94;
        loc = loc + 30;
        <D.22713>:
        <D.22389>:
        D.22701 = op->when;
        loc.8 = (unsigned int) loc;
        if (D.22701 > loc.8) goto <D.22388>; else goto <D.22390>;
        <D.22390>:
        D.22716 = op->op;
        D.22717 = (int) D.22716;
        switch (D.22717) <default: <D.22396>, case 12: <D.22391>, case 13: <D.22394>, case 14: <D.22393>, case 128: <D.22395>>
        <D.22391>:
        p.9 = p;
        p.14 = p.9;
        p.15 = p.14 + 1;
        p = p.15;
        D.22716 = op->op;
        *p.14 = D.22716;
        p.9 = p;
        reg.16 = (unsigned int) reg;
        encode_uleb128 (reg.16, p.9, &p);
        p.9 = p;
        D.22721 = op->val;
        D.22722 = (unsigned int) D.22721;
        encode_uleb128 (D.22722, p.9, &p);
        goto <D.22392>;
        <D.22393>:
        p.9 = p;
        p.17 = p.9;
        p.18 = p.17 + 1;
        p = p.18;
        D.22716 = op->op;
        *p.17 = D.22716;
        p.9 = p;
        D.22721 = op->val;
        D.22722 = (unsigned int) D.22721;
        encode_uleb128 (D.22722, p.9, &p);
        goto <D.22392>;
        <D.22394>:
        p.9 = p;
        p.19 = p.9;
        p.20 = p.19 + 1;
        p = p.20;
        D.22716 = op->op;
        *p.19 = D.22716;
        p.9 = p;
        reg.16 = (unsigned int) reg;
        encode_uleb128 (reg.16, p.9, &p);
        goto <D.22392>;
        <D.22395>:
        if (reg > 63) goto <D.22727>; else goto <D.22728>;
        <D.22727>:
        p.9 = p;
        p.21 = p.9;
        p.22 = p.21 + 1;
        p = p.22;
        *p.21 = 17;
        p.9 = p;
        reg.16 = (unsigned int) reg;
        encode_uleb128 (reg.16, p.9, &p);
        p.9 = p;
        D.22721 = op->val;
        D.22731 = D.22721 / -8;
        encode_sleb128 (D.22731, p.9, &p);
        goto <D.22732>;
        <D.22728>:
        p.9 = p;
        p.23 = p.9;
        p.24 = p.23 + 1;
        p = p.24;
        D.22735 = (signed char) reg;
        D.22736 = D.22735 | -128;
        D.22737 = (unsigned char) D.22736;
        *p.23 = D.22737;
        p.9 = p;
        D.22721 = op->val;
        D.22731 = D.22721 / -8;
        D.22738 = (unsigned int) D.22731;
        encode_uleb128 (D.22738, p.9, &p);
        <D.22732>:
        goto <D.22392>;
        <D.22396>:
        monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "unwind.c", 378);
        <D.22392>:
      }
      l = l->next;
      <D.22398>:
      if (l != 0B) goto <D.22397>; else goto <D.22399>;
      <D.22399>:
      p.9 = p;
      p.25 = (long int) p.9;
      buf.26 = (long int) buf;
      D.22741 = p.25 - buf.26;
      D.22742 = D.22741 > 4095;
      D.22743 = (long int) D.22742;
      D.22744 = __builtin_expect (D.22743, 0);
      if (D.22744 != 0) goto <D.22745>; else goto <D.22746>;
      <D.22745>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "unwind.c", 383, "p - buf < 4096");
      <D.22746>:
      p.9 = p;
      p.25 = (long int) p.9;
      buf.26 = (long int) buf;
      D.22741 = p.25 - buf.26;
      D.22747 = (unsigned int) D.22741;
      *out_len = D.22747;
      p.9 = p;
      p.25 = (long int) p.9;
      buf.26 = (long int) buf;
      D.22741 = p.25 - buf.26;
      D.22748 = (long unsigned int) D.22741;
      res = monoeg_malloc (D.22748);
      p.9 = p;
      p.25 = (long int) p.9;
      buf.26 = (long int) buf;
      D.22741 = p.25 - buf.26;
      D.22749 = (long unsigned int) D.22741;
      memcpy (res, buf, D.22749);
      monoeg_g_free (buf);
      D.22750 = res;
      return D.22750;
    }
  finally
    {
      p = {CLOBBER};
    }
}


encode_sleb128 (gint32 value, guint8 * buf, guint8 * * endbuf)
{
  _Bool D.22753;
  unsigned char D.22754;
  unsigned int D.22757;
  int D.22758;
  int D.22759;
  int D.22760;
  int D.22766;
  int D.22767;
  guint8 * p.27;
  gboolean more;
  gboolean negative;
  guint32 size;
  guint8 byte;
  guint8 * p;

  more = 1;
  D.22753 = value < 0;
  negative = (gboolean) D.22753;
  size = 32;
  p = buf;
  goto <D.22328>;
  <D.22327>:
  D.22754 = (unsigned char) value;
  byte = D.22754 & 127;
  value = value >> 7;
  if (negative != 0) goto <D.22755>; else goto <D.22756>;
  <D.22755>:
  D.22757 = size + 4294967289;
  D.22758 = (int) D.22757;
  D.22759 = 1 << D.22758;
  D.22760 = -D.22759;
  value = D.22760 | value;
  <D.22756>:
  if (value == 0) goto <D.22765>; else goto <D.22761>;
  <D.22765>:
  D.22766 = (int) byte;
  D.22767 = D.22766 & 64;
  if (D.22767 == 0) goto <D.22762>; else goto <D.22761>;
  <D.22761>:
  if (value == -1) goto <D.22768>; else goto <D.22763>;
  <D.22768>:
  D.22766 = (int) byte;
  D.22767 = D.22766 & 64;
  if (D.22767 != 0) goto <D.22762>; else goto <D.22763>;
  <D.22762>:
  more = 0;
  goto <D.22764>;
  <D.22763>:
  byte = byte | 128;
  <D.22764>:
  p.27 = p;
  p = p.27 + 1;
  *p.27 = byte;
  <D.22328>:
  if (more != 0) goto <D.22327>; else goto <D.22329>;
  <D.22329>:
  *endbuf = p;
}


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

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

    D.22770 = (unsigned char) value;
    b = D.22770 & 127;
    value = value >> 7;
    if (value != 0) goto <D.22771>; else goto <D.22772>;
    <D.22771>:
    b = b | 128;
    <D.22772>:
    p.28 = p;
    p = p.28 + 1;
    *p.28 = b;
  }
  if (value != 0) goto <D.22315>; else goto <D.22316>;
  <D.22316>:
  *endbuf = p;
}


memcpy (void * restrict __dest, const void * restrict __src, size_t __len)
{
  void * D.22774;
  long unsigned int D.22775;

  D.22775 = __builtin_object_size (__dest, 0);
  D.22774 = __builtin___memcpy_chk (__dest, __src, __len, D.22775);
  return D.22774;
}


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.22778;
  int D.22779;
  int D.22780;
  guint8 * p.30;
  unsigned int D.22782;
  unsigned int D.22783;
  int D.22784;
  unsigned int D.22785;
  unsigned int D.22786;
  unsigned int D.22787;
  unsigned int D.22788;
  unsigned int D.22789;
  _Bool D.22790;
  long int D.22791;
  long int D.22792;
  int D.22795;
  unsigned int D.22796;
  unsigned int D.22797;
  unsigned int D.22800;
  unsigned int pos.31;
  unsigned int D.22802;
  guint8 * p.32;
  long int D.22804;
  long int ip.33;
  long int start_ip.34;
  long int D.22807;
  sizetype D.22809;
  guint8 * D.22810;
  long unsigned int D.22813;
  long unsigned int D.22814;
  sizetype D.22815;
  int D.22816;
  long unsigned int D.22817;
  long unsigned int D.22818;
  mgreg_t * D.22819;
  long int D.22820;
  sizetype D.22821;
  sizetype D.22822;
  unsigned char D.22823;
  <unnamed type> D.22826;
  _Bool D.22829;
  long int D.22830;
  long int D.22831;
  long unsigned int D.22834;
  long unsigned int D.22835;
  mgreg_t * D.22836;
  int D.22837;
  sizetype D.22838;
  mgreg_t * D.22839;
  long int D.22840;
  _Bool D.22841;
  _Bool D.22842;
  _Bool D.22843;
  mgreg_t * * D.22846;
  struct Loc locations[17];
  guint8 reg_saved[17];
  int i;
  int pos;
  int reg;
  int cfa_reg;
  int cfa_offset;
  int offset;
  guint8 * p;
  guint8 * cfa_val;

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

        p.29 = p;
        D.22778 = *p.29;
        D.22779 = (int) D.22778;
        op = D.22779 & 192;
        switch (op) <default: <D.22448>, case 0: <D.22438>, case 64: <D.22435>, case 128: <D.22437>>
        <D.22435>:
        p.29 = p;
        D.22778 = *p.29;
        D.22779 = (int) D.22778;
        D.22780 = D.22779 & 63;
        pos = D.22780 + pos;
        p.29 = p;
        p.30 = p.29 + 1;
        p = p.30;
        goto <D.22436>;
        <D.22437>:
        p.29 = p;
        D.22778 = *p.29;
        D.22779 = (int) D.22778;
        reg = D.22779 & 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.22782 = decode_uleb128 (p.29, &p);
        D.22783 = D.22782 * 4294967288;
        D.22784 = (int) D.22783;
        locations[reg].offset = D.22784;
        goto <D.22436>;
        <D.22438>:
        {
          int ext_op;

          p.29 = p;
          D.22778 = *p.29;
          ext_op = (int) D.22778;
          p.29 = p;
          p.30 = p.29 + 1;
          p = p.30;
          switch (ext_op) <default: <D.22447>, case 4: <D.22446>, case 5: <D.22445>, case 12: <D.22440>, case 13: <D.22443>, case 14: <D.22442>, case 17: <D.22444>>
          <D.22440>:
          p.29 = p;
          D.22785 = decode_uleb128 (p.29, &p);
          cfa_reg = (int) D.22785;
          p.29 = p;
          D.22786 = decode_uleb128 (p.29, &p);
          cfa_offset = (int) D.22786;
          goto <D.22441>;
          <D.22442>:
          p.29 = p;
          D.22787 = decode_uleb128 (p.29, &p);
          cfa_offset = (int) D.22787;
          goto <D.22441>;
          <D.22443>:
          p.29 = p;
          D.22788 = decode_uleb128 (p.29, &p);
          cfa_reg = (int) D.22788;
          goto <D.22441>;
          <D.22444>:
          p.29 = p;
          D.22789 = decode_uleb128 (p.29, &p);
          reg = (int) D.22789;
          p.29 = p;
          offset = decode_sleb128 (p.29, &p);
          D.22790 = reg > 16;
          D.22791 = (long int) D.22790;
          D.22792 = __builtin_expect (D.22791, 0);
          if (D.22792 != 0) goto <D.22793>; else goto <D.22794>;
          <D.22793>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "unwind.c", 470, "reg < NUM_REGS");
          <D.22794>:
          reg_saved[reg] = 1;
          locations[reg].loc_type = 1;
          D.22795 = offset * -8;
          locations[reg].offset = D.22795;
          goto <D.22441>;
          <D.22445>:
          p.29 = p;
          D.22796 = decode_uleb128 (p.29, &p);
          reg = (int) D.22796;
          p.29 = p;
          D.22797 = decode_uleb128 (p.29, &p);
          offset = (int) D.22797;
          D.22790 = reg > 16;
          D.22791 = (long int) D.22790;
          D.22792 = __builtin_expect (D.22791, 0);
          if (D.22792 != 0) goto <D.22798>; else goto <D.22799>;
          <D.22798>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "unwind.c", 478, "reg < NUM_REGS");
          <D.22799>:
          reg_saved[reg] = 1;
          locations[reg].loc_type = 1;
          D.22795 = offset * -8;
          locations[reg].offset = D.22795;
          goto <D.22441>;
          <D.22446>:
          p.29 = p;
          D.22800 = MEM[(const guint32 *)p.29];
          pos.31 = (unsigned int) pos;
          D.22802 = D.22800 + pos.31;
          pos = (int) D.22802;
          p.29 = p;
          p.32 = p.29 + 4;
          p = p.32;
          goto <D.22441>;
          <D.22447>:
          monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "unwind.c", 488);
          <D.22441>:
          goto <D.22436>;
        }
        <D.22448>:
        monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "unwind.c", 493);
        <D.22436>:
      }
      <D.22450>:
      D.22804 = (long int) pos;
      ip.33 = (long int) ip;
      start_ip.34 = (long int) start_ip;
      D.22807 = ip.33 - start_ip.34;
      if (D.22804 <= D.22807) goto <D.22808>; else goto <D.22451>;
      <D.22808>:
      D.22809 = (sizetype) unwind_info_len;
      D.22810 = unwind_info + D.22809;
      p.29 = p;
      if (D.22810 > p.29) goto <D.22449>; else goto <D.22451>;
      <D.22451>:
      if (save_locations != 0B) goto <D.22811>; else goto <D.22812>;
      <D.22811>:
      D.22813 = (long unsigned int) save_locations_len;
      D.22814 = D.22813 * 8;
      memset (save_locations, 0, D.22814);
      <D.22812>:
      D.22815 = (sizetype) cfa_offset;
      D.22816 = mono_dwarf_reg_to_hw_reg (cfa_reg);
      D.22817 = (long unsigned int) D.22816;
      D.22818 = D.22817 * 8;
      D.22819 = regs + D.22818;
      D.22820 = *D.22819;
      D.22821 = (sizetype) D.22820;
      D.22822 = D.22815 + D.22821;
      cfa_val = (guint8 *) D.22822;
      i = 0;
      goto <D.22454>;
      <D.22453>:
      D.22823 = reg_saved[i];
      if (D.22823 != 0) goto <D.22824>; else goto <D.22825>;
      <D.22824>:
      D.22826 = locations[i].loc_type;
      if (D.22826 == 1) goto <D.22827>; else goto <D.22828>;
      <D.22827>:
      {
        int hreg;

        hreg = mono_dwarf_reg_to_hw_reg (i);
        D.22829 = hreg >= nregs;
        D.22830 = (long int) D.22829;
        D.22831 = __builtin_expect (D.22830, 0);
        if (D.22831 != 0) goto <D.22832>; else goto <D.22833>;
        <D.22832>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "unwind.c", 504, "hreg < nregs");
        <D.22833>:
        D.22834 = (long unsigned int) hreg;
        D.22835 = D.22834 * 8;
        D.22836 = regs + D.22835;
        D.22837 = locations[i].offset;
        D.22838 = (sizetype) D.22837;
        D.22839 = cfa_val + D.22838;
        D.22840 = *D.22839;
        *D.22836 = D.22840;
        D.22841 = save_locations != 0B;
        D.22842 = hreg < save_locations_len;
        D.22843 = D.22841 & D.22842;
        if (D.22843 != 0) goto <D.22844>; else goto <D.22845>;
        <D.22844>:
        D.22834 = (long unsigned int) hreg;
        D.22835 = D.22834 * 8;
        D.22846 = save_locations + D.22835;
        D.22837 = locations[i].offset;
        D.22838 = (sizetype) D.22837;
        D.22839 = cfa_val + D.22838;
        *D.22846 = D.22839;
        <D.22845>:
      }
      <D.22828>:
      <D.22825>:
      i = i + 1;
      <D.22454>:
      if (i <= 16) goto <D.22453>; else goto <D.22455>;
      <D.22455>:
      *out_cfa = cfa_val;
    }
  finally
    {
      locations = {CLOBBER};
      reg_saved = {CLOBBER};
      p = {CLOBBER};
    }
}


memset (void * __dest, int __ch, size_t __len)
{
  int D.22849;
  int D.22854;
  void * D.22856;
  long unsigned int D.22857;

  D.22849 = __builtin_constant_p (__len);
  if (D.22849 != 0) goto <D.22850>; else goto <D.22851>;
  <D.22850>:
  if (__len == 0) goto <D.22852>; else goto <D.22853>;
  <D.22852>:
  D.22854 = __builtin_constant_p (__ch);
  if (D.22854 == 0) goto <D.22847>; else goto <D.22855>;
  <D.22855>:
  if (__ch != 0) goto <D.22847>; else goto <D.22848>;
  <D.22847>:
  __warn_memset_zero_len ();
  D.22856 = __dest;
  return D.22856;
  <D.22848>:
  <D.22853>:
  <D.22851>:
  D.22857 = __builtin_object_size (__dest, 0);
  D.22856 = __builtin___memset_chk (__dest, __ch, __len, D.22857);
  return D.22856;
}


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


mono_unwind_cleanup ()
{
  struct MonoUnwindInfo * * cached_info.35;
  long unsigned int D.22862;
  long unsigned int D.22863;
  struct MonoUnwindInfo * * D.22864;
  int cached_info_next.36;
  int i;

  DeleteCriticalSection (&unwind_mutex);
  cached_info.35 = cached_info;
  if (cached_info.35 == 0B) goto <D.22860>; else goto <D.22861>;
  <D.22860>:
  return;
  <D.22861>:
  i = 0;
  goto <D.22465>;
  <D.22464>:
  {
    struct MonoUnwindInfo * cached;

    cached_info.35 = cached_info;
    D.22862 = (long unsigned int) i;
    D.22863 = D.22862 * 8;
    D.22864 = cached_info.35 + D.22863;
    cached = *D.22864;
    monoeg_g_free (cached);
  }
  i = i + 1;
  <D.22465>:
  cached_info_next.36 = cached_info_next;
  if (i < cached_info_next.36) goto <D.22464>; else goto <D.22466>;
  <D.22466>:
  cached_info.35 = cached_info;
  monoeg_g_free (cached_info.35);
}


mono_cache_unwind_info (guint8 * unwind_info, guint32 unwind_info_len)
{
  _Bool D.22869;
  long int D.22870;
  long int D.22871;
  struct MonoUnwindInfo * * cached_info.37;
  int cached_info_size.38;
  long unsigned int D.22878;
  long unsigned int D.22879;
  void * cached_info.39;
  long unsigned int D.22881;
  long unsigned int D.22882;
  struct MonoUnwindInfo * * D.22883;
  unsigned int D.22884;
  long unsigned int D.22887;
  guint8[0:] * D.22888;
  int D.22889;
  _Bool D.22894;
  long int D.22895;
  long int D.22896;
  guint32 D.22899;
  int cached_info_next.40;
  long unsigned int D.22901;
  long unsigned int D.22902;
  guint8[0:] * D.22903;
  int cached_info_size.43;
  long unsigned int D.22907;
  long unsigned int D.22908;
  struct GSList * cached_info_list.41;
  struct GSList * cached_info_list.42;
  int cached_info_next.44;
  int cached_info_next.45;
  long unsigned int D.22913;
  long unsigned int D.22914;
  struct MonoUnwindInfo * * D.22915;
  int unwind_info_size.46;
  unsigned int unwind_info_size.47;
  unsigned int D.22918;
  unsigned int D.22919;
  int unwind_info_size.48;
  _Bool D.22923;
  long int D.22924;
  long int D.22925;
  int i;
  struct MonoUnwindInfo * info;

  {
    int ret;

    ret = pthread_mutex_lock (&unwind_mutex.mutex);
    if (ret != 0) goto <D.22867>; else goto <D.22868>;
    <D.22867>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
    <D.22868>:
    D.22869 = ret != 0;
    D.22870 = (long int) D.22869;
    D.22871 = __builtin_expect (D.22870, 0);
    if (D.22871 != 0) goto <D.22872>; else goto <D.22873>;
    <D.22872>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "unwind.c", 557, "ret == 0");
    <D.22873>:
  }
  cached_info.37 = cached_info;
  if (cached_info.37 == 0B) goto <D.22875>; else goto <D.22876>;
  <D.22875>:
  cached_info_size = 16;
  cached_info_size.38 = cached_info_size;
  D.22878 = (long unsigned int) cached_info_size.38;
  D.22879 = D.22878 * 8;
  cached_info.39 = monoeg_malloc0 (D.22879);
  cached_info = cached_info.39;
  <D.22876>:
  i = 0;
  goto <D.22477>;
  <D.22476>:
  {
    struct MonoUnwindInfo * cached;

    cached_info.37 = cached_info;
    D.22881 = (long unsigned int) i;
    D.22882 = D.22881 * 8;
    D.22883 = cached_info.37 + D.22882;
    cached = *D.22883;
    D.22884 = cached->len;
    if (D.22884 == unwind_info_len) goto <D.22885>; else goto <D.22886>;
    <D.22885>:
    D.22887 = (long unsigned int) unwind_info_len;
    D.22888 = &cached->info;
    D.22889 = memcmp (D.22888, unwind_info, D.22887);
    if (D.22889 == 0) goto <D.22890>; else goto <D.22891>;
    <D.22890>:
    {
      int ret;

      ret = pthread_mutex_unlock (&unwind_mutex.mutex);
      if (ret != 0) goto <D.22892>; else goto <D.22893>;
      <D.22892>:
      monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
      <D.22893>:
      D.22894 = ret != 0;
      D.22895 = (long int) D.22894;
      D.22896 = __builtin_expect (D.22895, 0);
      if (D.22896 != 0) goto <D.22897>; else goto <D.22898>;
      <D.22897>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "unwind.c", 568, "ret == 0");
      <D.22898>:
    }
    D.22899 = (guint32) i;
    return D.22899;
    <D.22891>:
    <D.22886>:
  }
  i = i + 1;
  <D.22477>:
  cached_info_next.40 = cached_info_next;
  if (i < cached_info_next.40) goto <D.22476>; else goto <D.22478>;
  <D.22478>:
  D.22901 = (long unsigned int) unwind_info_len;
  D.22902 = D.22901 + 4;
  info = monoeg_malloc (D.22902);
  info->len = unwind_info_len;
  D.22887 = (long unsigned int) unwind_info_len;
  D.22903 = &info->info;
  memcpy (D.22903, unwind_info, D.22887);
  i = cached_info_next;
  cached_info_next.40 = cached_info_next;
  cached_info_size.38 = cached_info_size;
  if (cached_info_next.40 >= cached_info_size.38) goto <D.22904>; else goto <D.22905>;
  <D.22904>:
  {
    struct MonoUnwindInfo * * old_table;
    struct MonoUnwindInfo * * new_table;

    old_table = cached_info;
    cached_info_size.38 = cached_info_size;
    cached_info_size.43 = cached_info_size.38 * 2;
    D.22907 = (long unsigned int) cached_info_size.43;
    D.22908 = D.22907 * 8;
    new_table = monoeg_malloc0 (D.22908);
    cached_info_size.38 = cached_info_size;
    D.22878 = (long unsigned int) cached_info_size.38;
    D.22879 = D.22878 * 8;
    cached_info.37 = cached_info;
    memcpy (new_table, cached_info.37, D.22879);
    mono_memory_barrier ();
    cached_info = new_table;
    cached_info.37 = cached_info;
    cached_info_list.41 = cached_info_list;
    cached_info_list.42 = monoeg_g_slist_prepend (cached_info_list.41, cached_info.37);
    cached_info_list = cached_info_list.42;
    cached_info_size.38 = cached_info_size;
    cached_info_size.43 = cached_info_size.38 * 2;
    cached_info_size = cached_info_size.43;
  }
  <D.22905>:
  cached_info.37 = cached_info;
  cached_info_next.40 = cached_info_next;
  cached_info_next.44 = cached_info_next.40;
  cached_info_next.45 = cached_info_next.44 + 1;
  cached_info_next = cached_info_next.45;
  D.22913 = (long unsigned int) cached_info_next.44;
  D.22914 = D.22913 * 8;
  D.22915 = cached_info.37 + D.22914;
  *D.22915 = info;
  unwind_info_size.46 = unwind_info_size;
  unwind_info_size.47 = (unsigned int) unwind_info_size.46;
  D.22918 = unwind_info_size.47 + unwind_info_len;
  D.22919 = D.22918 + 4;
  unwind_info_size.48 = (int) D.22919;
  unwind_info_size = unwind_info_size.48;
  {
    int ret;

    ret = pthread_mutex_unlock (&unwind_mutex.mutex);
    if (ret != 0) goto <D.22921>; else goto <D.22922>;
    <D.22921>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.22922>:
    D.22923 = ret != 0;
    D.22924 = (long int) D.22923;
    D.22925 = __builtin_expect (D.22924, 0);
    if (D.22925 != 0) goto <D.22926>; else goto <D.22927>;
    <D.22926>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "unwind.c", 605, "ret == 0");
    <D.22927>:
  }
  D.22899 = (guint32) i;
  return D.22899;
}


mono_get_cached_unwind_info (guint32 index, guint32 * unwind_info_len)
{
  long unsigned int D.22929;
  long unsigned int D.22930;
  struct MonoUnwindInfo * * D.22931;
  unsigned int D.22932;
  guint8 * D.22933;
  struct MonoUnwindInfo * * table;
  struct MonoUnwindInfo * info;
  guint8 * data;

  table = cached_info;
  D.22929 = (long unsigned int) index;
  D.22930 = D.22929 * 8;
  D.22931 = table + D.22930;
  info = *D.22931;
  D.22932 = info->len;
  *unwind_info_len = D.22932;
  data = &info->info;
  D.22933 = data;
  return D.22933;
}


mono_unwind_get_dwarf_data_align ()
{
  int D.22935;

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


mono_unwind_get_dwarf_pc_reg ()
{
  int D.22937;

  D.22937 = mono_hw_reg_to_dwarf_reg (16);
  return D.22937;
}


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.49;
  unsigned int D.22940;
  unsigned int fde_len.50;
  unsigned int D.22942;
  _Bool D.22943;
  long int D.22944;
  long int D.22945;
  guint8 * p.51;
  sizetype D.22949;
  sizetype D.22950;
  _Bool D.22951;
  long int D.22952;
  long int D.22953;
  unsigned char D.22956;
  _Bool D.22957;
  long int D.22958;
  long int D.22959;
  guint8 * p.52;
  long unsigned int D.22963;
  sizetype D.22964;
  guint8 * p.53;
  unsigned int D.22966;
  unsigned int D.22967;
  char * D.22968;
  unsigned int D.22971;
  sizetype D.22972;
  char * D.22973;
  char D.22974;
  int D.22975;
  unsigned char D.22976;
  _Bool D.22977;
  long int D.22978;
  long int D.22979;
  _Bool D.22982;
  long int D.22983;
  long int D.22984;
  sizetype D.22987;
  guint8 * p.54;
  sizetype D.22989;
  unsigned int D.22992;
  sizetype D.22993;
  guint8 * p.55;
  sizetype D.22996;
  sizetype D.22997;
  guint8 * D.22998;
  long int D.22999;
  long int p.56;
  long int D.23001;
  unsigned int pc_range.57;
  unsigned int D.23011;
  long int D.23015;
  sizetype D.23019;
  _Bool D.23020;
  long int D.23021;
  long int D.23022;
  _Bool D.23025;
  long int D.23026;
  long int D.23027;
  int D.23030;
  _Bool D.23031;
  long int D.23032;
  long int D.23033;
  sizetype D.23036;
  sizetype D.23037;
  guint8 * D.23038;
  long int D.23039;
  long int cie_cfi.58;
  long int D.23041;
  unsigned int D.23042;
  long int fde_cfi.59;
  long int D.23044;
  unsigned int D.23045;
  unsigned int D.23046;
  long unsigned int D.23047;
  long int D.23049;
  long unsigned int D.23050;
  guint8 * D.23051;
  unsigned int D.23052;
  unsigned int i.60;
  unsigned int D.23054;
  long int D.23056;
  long unsigned int D.23057;
  unsigned int D.23058;
  unsigned int D.23059;
  _Bool D.23060;
  long int D.23061;
  long int D.23062;
  unsigned int i.61;
  guint8 * D.23066;
  long unsigned int D.23067;
  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.49 = p;
      D.22940 = MEM[(guint32 *)p.49];
      fde_len = (gint32) D.22940;
      fde_len.50 = (unsigned int) fde_len;
      D.22942 = fde_len.50 + 1;
      D.22943 = D.22942 <= 1;
      D.22944 = (long int) D.22943;
      D.22945 = __builtin_expect (D.22944, 0);
      if (D.22945 != 0) goto <D.22946>; else goto <D.22947>;
      <D.22946>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "unwind.c", 833, "fde_len != 0xffffffff && fde_len != 0");
      <D.22947>:
      p.49 = p;
      p.51 = p.49 + 4;
      p = p.51;
      p.49 = p;
      D.22940 = MEM[(guint32 *)p.49];
      cie_offset = (gint32) D.22940;
      p.49 = p;
      D.22949 = (sizetype) cie_offset;
      D.22950 = -D.22949;
      cie = p.49 + D.22950;
      p.49 = p;
      p.51 = p.49 + 4;
      p = p.51;
      fde_current = p;
      p = cie;
      p.49 = p;
      D.22940 = MEM[(guint32 *)p.49];
      cie_len = (gint32) D.22940;
      p.49 = p;
      p.51 = p.49 + 4;
      p = p.51;
      p.49 = p;
      D.22940 = MEM[(guint32 *)p.49];
      cie_id = (gint32) D.22940;
      D.22951 = cie_id != 0;
      D.22952 = (long int) D.22951;
      D.22953 = __builtin_expect (D.22952, 0);
      if (D.22953 != 0) goto <D.22954>; else goto <D.22955>;
      <D.22954>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "unwind.c", 845, "cie_id == 0");
      <D.22955>:
      p.49 = p;
      p.51 = p.49 + 4;
      p = p.51;
      p.49 = p;
      D.22956 = *p.49;
      cie_version = (gint32) D.22956;
      D.22957 = cie_version != 1;
      D.22958 = (long int) D.22957;
      D.22959 = __builtin_expect (D.22958, 0);
      if (D.22959 != 0) goto <D.22960>; else goto <D.22961>;
      <D.22960>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "unwind.c", 848, "cie_version == 1");
      <D.22961>:
      p.49 = p;
      p.52 = p.49 + 1;
      p = p.52;
      cie_aug_str = p;
      p.49 = p;
      D.22963 = strlen (cie_aug_str);
      D.22964 = D.22963 + 1;
      p.53 = p.49 + D.22964;
      p = p.53;
      p.49 = p;
      D.22966 = decode_uleb128 (p.49, &p);
      code_align = (gint32) D.22966;
      p.49 = p;
      data_align = decode_sleb128 (p.49, &p);
      p.49 = p;
      D.22967 = decode_uleb128 (p.49, &p);
      return_reg = (gint32) D.22967;
      D.22968 = __builtin_strchr (cie_aug_str, 122);
      if (D.22968 != 0B) goto <D.22969>; else goto <D.22970>;
      <D.22969>:
      {
        guint8 * cie_aug;
        guint32 p_encoding;

        p.49 = p;
        D.22971 = decode_uleb128 (p.49, &p);
        cie_aug_len = (gint32) D.22971;
        has_fde_augmentation = 1;
        cie_aug = p;
        i = 0;
        goto <D.22592>;
        <D.22591>:
        D.22972 = (sizetype) i;
        D.22973 = cie_aug_str + D.22972;
        D.22974 = *D.22973;
        D.22975 = (int) D.22974;
        switch (D.22975) <default: <D.22590>, case 76: <D.22588>, case 80: <D.22587>, case 82: <D.22589>, case 122: <D.22585>>
        <D.22585>:
        goto <D.22586>;
        <D.22587>:
        p.49 = p;
        D.22956 = *p.49;
        p_encoding = (guint32) D.22956;
        p.49 = p;
        p.52 = p.49 + 1;
        p = p.52;
        p.49 = p;
        read_encoded_val (p_encoding, p.49, &p);
        goto <D.22586>;
        <D.22588>:
        p.49 = p;
        D.22956 = *p.49;
        D.22976 = D.22956 + 229;
        D.22977 = D.22976 > 1;
        D.22978 = (long int) D.22977;
        D.22979 = __builtin_expect (D.22978, 0);
        if (D.22979 != 0) goto <D.22980>; else goto <D.22981>;
        <D.22980>:
        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.22981>:
        p.49 = p;
        p.52 = p.49 + 1;
        p = p.52;
        goto <D.22586>;
        <D.22589>:
        p.49 = p;
        D.22956 = *p.49;
        D.22982 = D.22956 != 27;
        D.22983 = (long int) D.22982;
        D.22984 = __builtin_expect (D.22983, 0);
        if (D.22984 != 0) goto <D.22985>; else goto <D.22986>;
        <D.22985>:
        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.22986>:
        p.49 = p;
        p.52 = p.49 + 1;
        p = p.52;
        goto <D.22586>;
        <D.22590>:
        monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "unwind.c", 882);
        <D.22586>:
        i = i + 1;
        <D.22592>:
        D.22972 = (sizetype) i;
        D.22973 = cie_aug_str + D.22972;
        D.22974 = *D.22973;
        if (D.22974 != 0) goto <D.22591>; else goto <D.22593>;
        <D.22593>:
        p = cie_aug;
        p.49 = p;
        D.22987 = (sizetype) cie_aug_len;
        p.54 = p.49 + D.22987;
        p = p.54;
      }
      <D.22970>:
      cie_cfi = p;
      p = fde_current;
      p.49 = p;
      pc_begin = MEM[(gint32 *)p.49];
      p.49 = p;
      D.22989 = (sizetype) pc_begin;
      code = p.49 + D.22989;
      p.49 = p;
      p.51 = p.49 + 4;
      p = p.51;
      p.49 = p;
      D.22940 = MEM[(guint32 *)p.49];
      pc_range = (gint32) D.22940;
      p.49 = p;
      p.51 = p.49 + 4;
      p = p.51;
      if (has_fde_augmentation != 0) goto <D.22990>; else goto <D.22991>;
      <D.22990>:
      p.49 = p;
      D.22992 = decode_uleb128 (p.49, &p);
      aug_len = (gint32) D.22992;
      fde_aug = p;
      p.49 = p;
      D.22993 = (sizetype) aug_len;
      p.55 = p.49 + D.22993;
      p = p.55;
      goto <D.22995>;
      <D.22991>:
      aug_len = 0;
      <D.22995>:
      fde_cfi = p;
      D.22996 = (sizetype) fde_len;
      D.22997 = D.22996 + 4;
      D.22998 = fde + D.22997;
      D.22999 = (long int) D.22998;
      p.49 = p;
      p.56 = (long int) p.49;
      D.23001 = D.22999 - p.56;
      fde_data_len = (gint32) D.23001;
      if (code_len != 0B) goto <D.23002>; else goto <D.23003>;
      <D.23002>:
      pc_range.57 = (unsigned int) pc_range;
      *code_len = pc_range.57;
      <D.23003>:
      if (ex_info != 0B) goto <D.23005>; else goto <D.23006>;
      <D.23005>:
      *ex_info = 0B;
      *ex_info_len = 0;
      <D.23006>:
      if (aug_len != 0) goto <D.23007>; else goto <D.23008>;
      <D.23007>:
      {
        gint32 lsda_offset;
        guint8 * lsda;

        if (aug_len == 4) goto <D.23009>; else goto <D.23010>;
        <D.23009>:
        D.23011 = MEM[(const guint32 *)fde_aug];
        lsda_offset = (gint32) D.23011;
        goto <D.23012>;
        <D.23010>:
        if (aug_len == 8) goto <D.23013>; else goto <D.23014>;
        <D.23013>:
        D.23015 = MEM[(gint64 *)fde_aug];
        lsda_offset = (gint32) D.23015;
        goto <D.23016>;
        <D.23014>:
        monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "unwind.c", 929);
        <D.23016>:
        <D.23012>:
        if (lsda_offset != 0) goto <D.23017>; else goto <D.23018>;
        <D.23017>:
        D.23019 = (sizetype) lsda_offset;
        lsda = fde_aug + D.23019;
        decode_lsda (lsda, code, ex_info, ex_info_len, type_info, this_reg, this_offset);
        <D.23018>:
      }
      <D.23008>:
      D.23020 = code_align != 1;
      D.23021 = (long int) D.23020;
      D.23022 = __builtin_expect (D.23021, 0);
      if (D.23022 != 0) goto <D.23023>; else goto <D.23024>;
      <D.23023>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "unwind.c", 938, "code_align == 1");
      <D.23024>:
      D.23025 = data_align != -8;
      D.23026 = (long int) D.23025;
      D.23027 = __builtin_expect (D.23026, 0);
      if (D.23027 != 0) goto <D.23028>; else goto <D.23029>;
      <D.23028>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "unwind.c", 939, "data_align == DWARF_DATA_ALIGN");
      <D.23029>:
      D.23030 = mono_hw_reg_to_dwarf_reg (16);
      D.23031 = D.23030 != return_reg;
      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", 940, "return_reg == DWARF_PC_REG");
      <D.23035>:
      D.23036 = (sizetype) cie_len;
      D.23037 = D.23036 + 4;
      D.23038 = cie + D.23037;
      D.23039 = (long int) D.23038;
      cie_cfi.58 = (long int) cie_cfi;
      D.23041 = D.23039 - cie_cfi.58;
      D.23042 = (unsigned int) D.23041;
      D.22996 = (sizetype) fde_len;
      D.22997 = D.22996 + 4;
      D.22998 = fde + D.22997;
      D.22999 = (long int) D.22998;
      fde_cfi.59 = (long int) fde_cfi;
      D.23044 = D.22999 - fde_cfi.59;
      D.23045 = (unsigned int) D.23044;
      D.23046 = D.23042 + D.23045;
      buf_len = (gint32) D.23046;
      D.23047 = (long unsigned int) buf_len;
      buf = monoeg_malloc0 (D.23047);
      i = 0;
      p = cie_cfi;
      goto <D.22598>;
      <D.22597>:
      p.49 = p;
      D.22956 = *p.49;
      if (D.22956 == 0) goto <D.22596>; else goto <D.23048>;
      <D.23048>:
      p.49 = p;
      decode_cie_op (p.49, &p);
      <D.22598>:
      D.23036 = (sizetype) cie_len;
      D.23037 = D.23036 + 4;
      D.23038 = cie + D.23037;
      p.49 = p;
      if (D.23038 > p.49) goto <D.22597>; else goto <D.22596>;
      <D.22596>:
      p.49 = p;
      p.56 = (long int) p.49;
      cie_cfi.58 = (long int) cie_cfi;
      D.23049 = p.56 - cie_cfi.58;
      D.23050 = (long unsigned int) D.23049;
      D.22972 = (sizetype) i;
      D.23051 = buf + D.22972;
      memcpy (D.23051, cie_cfi, D.23050);
      p.49 = p;
      p.56 = (long int) p.49;
      cie_cfi.58 = (long int) cie_cfi;
      D.23049 = p.56 - cie_cfi.58;
      D.23052 = (unsigned int) D.23049;
      i.60 = (unsigned int) i;
      D.23054 = D.23052 + i.60;
      i = (gint32) D.23054;
      p = fde_cfi;
      goto <D.22601>;
      <D.22600>:
      p.49 = p;
      D.22956 = *p.49;
      if (D.22956 == 0) goto <D.22599>; else goto <D.23055>;
      <D.23055>:
      p.49 = p;
      decode_cie_op (p.49, &p);
      <D.22601>:
      D.22996 = (sizetype) fde_len;
      D.22997 = D.22996 + 4;
      D.22998 = fde + D.22997;
      p.49 = p;
      if (D.22998 > p.49) goto <D.22600>; else goto <D.22599>;
      <D.22599>:
      p.49 = p;
      p.56 = (long int) p.49;
      fde_cfi.59 = (long int) fde_cfi;
      D.23056 = p.56 - fde_cfi.59;
      D.23057 = (long unsigned int) D.23056;
      D.22972 = (sizetype) i;
      D.23051 = buf + D.22972;
      memcpy (D.23051, fde_cfi, D.23057);
      p.49 = p;
      p.56 = (long int) p.49;
      fde_cfi.59 = (long int) fde_cfi;
      D.23056 = p.56 - fde_cfi.59;
      D.23058 = (unsigned int) D.23056;
      i.60 = (unsigned int) i;
      D.23059 = D.23058 + i.60;
      i = (gint32) D.23059;
      D.23060 = i > buf_len;
      D.23061 = (long int) D.23060;
      D.23062 = __builtin_expect (D.23061, 0);
      if (D.23062 != 0) goto <D.23063>; else goto <D.23064>;
      <D.23063>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "unwind.c", 965, "i <= buf_len");
      <D.23064>:
      i.61 = (unsigned int) i;
      *out_len = i.61;
      D.23067 = (long unsigned int) i;
      D.23066 = monoeg_realloc (buf, D.23067);
      return D.23066;
    }
  finally
    {
      p = {CLOBBER};
    }
}


read_encoded_val (guint32 encoding, guint8 * p, guint8 * * endp)
{
  unsigned int D.23071;
  int D.23072;
  gint64 D.23073;
  gint64 res;

  D.23071 = encoding & 15;
  switch (D.23071) <default: <D.22522>, case 11: <D.22521>, case 12: <D.22519>>
  <D.22519>:
  res = MEM[(gint64 *)p];
  p = p + 8;
  goto <D.22520>;
  <D.22521>:
  D.23072 = MEM[(gint32 *)p];
  res = (gint64) D.23072;
  p = p + 4;
  goto <D.22520>;
  <D.22522>:
  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "unwind.c", 717);
  <D.22520>:
  *endp = p;
  D.23073 = res;
  return D.23073;
}


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.62;
  _Bool D.23076;
  long int D.23077;
  long int D.23078;
  _Bool D.23081;
  long int D.23082;
  long int D.23083;
  unsigned char D.23086;
  guint8 * p.63;
  _Bool D.23090;
  long int D.23091;
  long int D.23092;
  unsigned int D.23095;
  int D.23096;
  _Bool D.23098;
  long int D.23099;
  long int D.23100;
  unsigned int D.23103;
  long unsigned int p.64;
  long unsigned int D.23105;
  long unsigned int D.23106;
  guint8 * p.65;
  long unsigned int D.23110;
  long unsigned int D.23111;
  void * D.23112;
  unsigned int ncall_sites.66;
  long unsigned int D.23116;
  void * D.23117;
  unsigned int D.23118;
  guint8 * p.67;
  _Bool D.23120;
  long int D.23121;
  long int D.23122;
  long unsigned int tinfo.68;
  long unsigned int D.23126;
  _Bool D.23127;
  long int D.23128;
  long int D.23129;
  void * * D.23134;
  long unsigned int D.23137;
  long unsigned int D.23138;
  void * * D.23139;
  struct MonoJitExceptionInfo * D.23140;
  long unsigned int D.23141;
  struct MonoJitExceptionInfo * D.23142;
  sizetype D.23143;
  void * D.23144;
  sizetype D.23145;
  sizetype D.23146;
  guint8 * D.23147;
  sizetype D.23148;
  void * D.23149;
  guint8 * p;
  int i;
  int ncall_sites;
  int this_encoding;
  guint32 mono_magic;
  guint32 version;

  try
    {
      p = lsda;
      p.62 = p;
      mono_magic = decode_uleb128 (p.62, &p);
      D.23076 = mono_magic != 1297084239;
      D.23077 = (long int) D.23076;
      D.23078 = __builtin_expect (D.23077, 0);
      if (D.23078 != 0) goto <D.23079>; else goto <D.23080>;
      <D.23079>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "unwind.c", 740, "mono_magic == 0x4d4fef4f");
      <D.23080>:
      p.62 = p;
      version = decode_uleb128 (p.62, &p);
      D.23081 = version != 1;
      D.23082 = (long int) D.23081;
      D.23083 = __builtin_expect (D.23082, 0);
      if (D.23083 != 0) goto <D.23084>; else goto <D.23085>;
      <D.23084>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "unwind.c", 742, "version == 1");
      <D.23085>:
      p.62 = p;
      D.23086 = *p.62;
      this_encoding = (int) D.23086;
      p.62 = p;
      p.63 = p.62 + 1;
      p = p.63;
      if (this_encoding == 3) goto <D.23088>; else goto <D.23089>;
      <D.23088>:
      {
        gint32 op;
        gint32 reg;
        gint32 offset;

        p.62 = p;
        D.23086 = *p.62;
        op = (gint32) D.23086;
        D.23090 = op != 146;
        D.23091 = (long int) D.23090;
        D.23092 = __builtin_expect (D.23091, 0);
        if (D.23092 != 0) goto <D.23093>; else goto <D.23094>;
        <D.23093>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "unwind.c", 750, "op == DW_OP_bregx");
        <D.23094>:
        p.62 = p;
        p.63 = p.62 + 1;
        p = p.63;
        p.62 = p;
        D.23095 = decode_uleb128 (p.62, &p);
        reg = (gint32) D.23095;
        p.62 = p;
        offset = decode_sleb128 (p.62, &p);
        D.23096 = mono_dwarf_reg_to_hw_reg (reg);
        *this_reg = D.23096;
        *this_offset = offset;
      }
      goto <D.23097>;
      <D.23089>:
      D.23098 = this_encoding != 255;
      D.23099 = (long int) D.23098;
      D.23100 = __builtin_expect (D.23099, 0);
      if (D.23100 != 0) goto <D.23101>; else goto <D.23102>;
      <D.23101>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "unwind.c", 758, "this_encoding == DW_EH_PE_omit");
      <D.23102>:
      *this_reg = -1;
      *this_offset = -1;
      <D.23097>:
      p.62 = p;
      D.23103 = decode_uleb128 (p.62, &p);
      ncall_sites = (int) D.23103;
      p.62 = p;
      p.64 = (long unsigned int) p.62;
      D.23105 = p.64 + 3;
      D.23106 = D.23105 & 18446744073709551612;
      p.65 = (guint8 *) D.23106;
      p = p.65;
      if (ex_info != 0B) goto <D.23108>; else goto <D.23109>;
      <D.23108>:
      D.23110 = (long unsigned int) ncall_sites;
      D.23111 = D.23110 * 40;
      D.23112 = monoeg_malloc0 (D.23111);
      *ex_info = D.23112;
      ncall_sites.66 = (unsigned int) ncall_sites;
      *ex_info_len = ncall_sites.66;
      <D.23109>:
      if (type_info != 0B) goto <D.23114>; else goto <D.23115>;
      <D.23114>:
      D.23110 = (long unsigned int) ncall_sites;
      D.23116 = D.23110 * 8;
      D.23117 = monoeg_malloc0 (D.23116);
      *type_info = D.23117;
      <D.23115>:
      i = 0;
      goto <D.22546>;
      <D.22545>:
      {
        int block_start_offset;
        int block_size;
        int landing_pad;
        guint8 * tinfo;

        p.62 = p;
        D.23118 = MEM[(const guint32 *)p.62];
        block_start_offset = (int) D.23118;
        p.62 = p;
        p.67 = p.62 + 4;
        p = p.67;
        p.62 = p;
        D.23118 = MEM[(const guint32 *)p.62];
        block_size = (int) D.23118;
        p.62 = p;
        p.67 = p.62 + 4;
        p = p.67;
        p.62 = p;
        D.23118 = MEM[(const guint32 *)p.62];
        landing_pad = (int) D.23118;
        p.62 = p;
        p.67 = p.62 + 4;
        p = p.67;
        tinfo = p;
        p.62 = p;
        p.67 = p.62 + 4;
        p = p.67;
        D.23120 = landing_pad == 0;
        D.23121 = (long int) D.23120;
        D.23122 = __builtin_expect (D.23121, 0);
        if (D.23122 != 0) goto <D.23123>; else goto <D.23124>;
        <D.23123>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "unwind.c", 786, "landing_pad");
        <D.23124>:
        tinfo.68 = (long unsigned int) tinfo;
        D.23126 = tinfo.68 & 3;
        D.23127 = D.23126 != 0;
        D.23128 = (long int) D.23127;
        D.23129 = __builtin_expect (D.23128, 0);
        if (D.23129 != 0) goto <D.23130>; else goto <D.23131>;
        <D.23130>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "unwind.c", 787, "((size_t)tinfo % 4) == 0");
        <D.23131>:
        if (ex_info != 0B) goto <D.23132>; else goto <D.23133>;
        <D.23132>:
        D.23134 = *type_info;
        if (D.23134 != 0B) goto <D.23135>; else goto <D.23136>;
        <D.23135>:
        D.23134 = *type_info;
        D.23137 = (long unsigned int) i;
        D.23138 = D.23137 * 8;
        D.23139 = D.23134 + D.23138;
        *D.23139 = tinfo;
        <D.23136>:
        D.23140 = *ex_info;
        D.23137 = (long unsigned int) i;
        D.23141 = D.23137 * 40;
        D.23142 = D.23140 + D.23141;
        D.23143 = (sizetype) block_start_offset;
        D.23144 = code + D.23143;
        D.23142->try_start = D.23144;
        D.23140 = *ex_info;
        D.23137 = (long unsigned int) i;
        D.23141 = D.23137 * 40;
        D.23142 = D.23140 + D.23141;
        D.23143 = (sizetype) block_start_offset;
        D.23145 = (sizetype) block_size;
        D.23146 = D.23143 + D.23145;
        D.23147 = code + D.23146;
        D.23142->try_end = D.23147;
        D.23140 = *ex_info;
        D.23137 = (long unsigned int) i;
        D.23141 = D.23137 * 40;
        D.23142 = D.23140 + D.23141;
        D.23148 = (sizetype) landing_pad;
        D.23149 = code + D.23148;
        D.23142->handler_start = D.23149;
        <D.23133>:
      }
      i = i + 1;
      <D.22546>:
      if (i < ncall_sites) goto <D.22545>; else goto <D.22547>;
      <D.22547>:
    }
  finally
    {
      p = {CLOBBER};
    }
}


decode_cie_op (guint8 * p, guint8 * * endp)
{
  guint8 * p.69;
  unsigned char D.23151;
  int D.23152;
  guint8 * p.70;
  guint8 * p.71;
  int op;

  p.69 = p;
  D.23151 = *p.69;
  D.23152 = (int) D.23151;
  op = D.23152 & 192;
  switch (op) <default: <D.22512>, case 0: <D.22503>, case 64: <D.22500>, case 128: <D.22502>>
  <D.22500>:
  p.69 = p;
  p.70 = p.69 + 1;
  p = p.70;
  goto <D.22501>;
  <D.22502>:
  p.69 = p;
  p.70 = p.69 + 1;
  p = p.70;
  p.69 = p;
  decode_uleb128 (p.69, &p);
  goto <D.22501>;
  <D.22503>:
  {
    int ext_op;

    p.69 = p;
    D.23151 = *p.69;
    ext_op = (int) D.23151;
    p.69 = p;
    p.70 = p.69 + 1;
    p = p.70;
    switch (ext_op) <default: <D.22511>, case 4: <D.22509>, case 12: <D.22505>, case 13: <D.22508>, case 14: <D.22507>, case 17: <D.22510>>
    <D.22505>:
    p.69 = p;
    decode_uleb128 (p.69, &p);
    p.69 = p;
    decode_uleb128 (p.69, &p);
    goto <D.22506>;
    <D.22507>:
    p.69 = p;
    decode_uleb128 (p.69, &p);
    goto <D.22506>;
    <D.22508>:
    p.69 = p;
    decode_uleb128 (p.69, &p);
    goto <D.22506>;
    <D.22509>:
    p.69 = p;
    p.71 = p.69 + 4;
    p = p.71;
    goto <D.22506>;
    <D.22510>:
    p.69 = p;
    decode_uleb128 (p.69, &p);
    p.69 = p;
    decode_uleb128 (p.69, &p);
    goto <D.22506>;
    <D.22511>:
    monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "unwind.c", 691);
    <D.22506>:
    goto <D.22501>;
  }
  <D.22512>:
  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "unwind.c", 696);
  <D.22501>:
  p.69 = p;
  *endp = p.69;
}


mono_unwind_decode_llvm_mono_fde (guint8 * fde, int fde_len, guint8 * cie, guint8 * code, struct MonoLLVMFDEInfo * res)
{
  guint8 * p.72;
  unsigned char D.23156;
  guint8 * p.73;
  unsigned int D.23160;
  guint8 * p.74;
  sizetype D.23163;
  guint8 * p.75;
  int * D.23167;
  int * D.23168;
  void * * * D.23169;
  guint32 * D.23170;
  struct MonoJitExceptionInfo * * D.23171;
  unsigned int D.23172;
  unsigned int D.23173;
  unsigned int pers_encoding.76;
  _Bool D.23177;
  long int D.23178;
  long int D.23179;
  _Bool D.23182;
  long int D.23183;
  long int D.23184;
  int D.23187;
  _Bool D.23188;
  long int D.23189;
  long int D.23190;
  long int p.77;
  long int cie_cfi.78;
  long int D.23196;
  sizetype D.23197;
  guint8 * D.23198;
  long int D.23199;
  long int fde_cfi.79;
  long int D.23201;
  int D.23202;
  long unsigned int D.23203;
  long unsigned int D.23204;
  long unsigned int D.23205;
  sizetype D.23206;
  guint8 * D.23207;
  unsigned int D.23208;
  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.72 = p;
      D.23156 = *p.72;
      has_aug = (int) D.23156;
      p.72 = p;
      p.73 = p.72 + 1;
      p = p.73;
      if (has_aug != 0) goto <D.23158>; else goto <D.23159>;
      <D.23158>:
      p.72 = p;
      D.23160 = MEM[(const guint32 *)p.72];
      aug_len = (int) D.23160;
      p.72 = p;
      p.74 = p.72 + 4;
      p = p.74;
      goto <D.23162>;
      <D.23159>:
      aug_len = 0;
      <D.23162>:
      fde_aug = p;
      p.72 = p;
      D.23163 = (sizetype) aug_len;
      p.75 = p.72 + D.23163;
      p = p.75;
      fde_cfi = p;
      if (has_aug != 0) goto <D.23165>; else goto <D.23166>;
      <D.23165>:
      {
        guint8 * lsda;

        lsda = fde_aug;
        D.23167 = &res->this_offset;
        D.23168 = &res->this_reg;
        D.23169 = &res->type_info;
        D.23170 = &res->ex_info_len;
        D.23171 = &res->ex_info;
        decode_lsda (lsda, code, D.23171, D.23170, D.23169, D.23168, D.23167);
      }
      <D.23166>:
      p = cie;
      p.72 = p;
      D.23172 = decode_uleb128 (p.72, &p);
      code_align = (gint32) D.23172;
      p.72 = p;
      data_align = decode_sleb128 (p.72, &p);
      p.72 = p;
      D.23173 = decode_uleb128 (p.72, &p);
      return_reg = (gint32) D.23173;
      p.72 = p;
      D.23156 = *p.72;
      pers_encoding = (gint32) D.23156;
      p.72 = p;
      p.73 = p.72 + 1;
      p = p.73;
      if (pers_encoding != 255) goto <D.23174>; else goto <D.23175>;
      <D.23174>:
      p.72 = p;
      pers_encoding.76 = (unsigned int) pers_encoding;
      read_encoded_val (pers_encoding.76, p.72, &p);
      <D.23175>:
      cie_cfi = p;
      D.23177 = code_align != 1;
      D.23178 = (long int) D.23177;
      D.23179 = __builtin_expect (D.23178, 0);
      if (D.23179 != 0) goto <D.23180>; else goto <D.23181>;
      <D.23180>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "unwind.c", 1028, "code_align == 1");
      <D.23181>:
      D.23182 = data_align != -8;
      D.23183 = (long int) D.23182;
      D.23184 = __builtin_expect (D.23183, 0);
      if (D.23184 != 0) goto <D.23185>; else goto <D.23186>;
      <D.23185>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "unwind.c", 1029, "data_align == DWARF_DATA_ALIGN");
      <D.23186>:
      D.23187 = mono_hw_reg_to_dwarf_reg (16);
      D.23188 = D.23187 != return_reg;
      D.23189 = (long int) D.23188;
      D.23190 = __builtin_expect (D.23189, 0);
      if (D.23190 != 0) goto <D.23191>; else goto <D.23192>;
      <D.23191>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "unwind.c", 1030, "return_reg == DWARF_PC_REG");
      <D.23192>:
      p = cie_cfi;
      <D.22624>:
      p.72 = p;
      D.23156 = *p.72;
      if (D.23156 == 0) goto <D.22623>; else goto <D.23193>;
      <D.23193>:
      p.72 = p;
      decode_cie_op (p.72, &p);
      goto <D.22624>;
      <D.22623>:
      p.72 = p;
      p.77 = (long int) p.72;
      cie_cfi.78 = (long int) cie_cfi;
      D.23196 = p.77 - cie_cfi.78;
      cie_cfi_len = (int) D.23196;
      D.23197 = (sizetype) fde_len;
      D.23198 = fde + D.23197;
      D.23199 = (long int) D.23198;
      fde_cfi.79 = (long int) fde_cfi;
      D.23201 = D.23199 - fde_cfi.79;
      fde_cfi_len = (int) D.23201;
      D.23202 = cie_cfi_len + fde_cfi_len;
      D.23203 = (long unsigned int) D.23202;
      buf = monoeg_malloc0 (D.23203);
      D.23204 = (long unsigned int) cie_cfi_len;
      memcpy (buf, cie_cfi, D.23204);
      D.23205 = (long unsigned int) fde_cfi_len;
      D.23206 = (sizetype) cie_cfi_len;
      D.23207 = buf + D.23206;
      memcpy (D.23207, fde_cfi, D.23205);
      D.23202 = cie_cfi_len + fde_cfi_len;
      D.23208 = (unsigned int) D.23202;
      res->unw_info_len = D.23208;
      res->unw_info = buf;
    }
  finally
    {
      p = {CLOBBER};
    }
}


mono_unwind_get_cie_program ()
{
  struct GSList * D.23209;

  D.23209 = mono_arch_get_cie_program ();
  return D.23209;
}