mono_hw_reg_to_dwarf_reg (int reg)
{
  int D.24713;

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


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

  dwarf_reg_to_hw_reg_inited.0 = dwarf_reg_to_hw_reg_inited;
  if (dwarf_reg_to_hw_reg_inited.0 == 0) goto <D.24716>; else goto <D.24717>;
  <D.24716>:
  init_reg_map ();
  <D.24717>:
  D.24718 = map_dwarf_reg_to_hw_reg[reg];
  return D.24718;
}


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

  if (0 != 0) goto <D.24720>; else goto <D.24721>;
  <D.24720>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "unwind.c", 138, "NUM_REGS > 0");
  <D.24721>:
  i = 0;
  goto <D.24383>;
  <D.24382>:
  D.24722 = mono_hw_reg_to_dwarf_reg (i);
  map_dwarf_reg_to_hw_reg[D.24722] = i;
  i = i + 1;
  <D.24383>:
  i.1 = (unsigned int) i;
  if (i.1 <= 23) goto <D.24382>; else goto <D.24384>;
  <D.24384>:
  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.24725;
  int D.24726;
  int D.24727;
  guint8 * p.3;
  unsigned int D.24729;
  unsigned int D.24730;
  int D.24731;
  int D.24734;
  int D.24736;
  const char * D.24737;
  unsigned int D.24738;
  unsigned int D.24739;
  int D.24740;
  const char * D.24741;
  unsigned int D.24742;
  unsigned int D.24743;
  int D.24744;
  const char * D.24745;
  unsigned int D.24746;
  int D.24747;
  int D.24748;
  const char * D.24749;
  unsigned int D.24750;
  unsigned int pos.4;
  unsigned int D.24752;
  guint8 * p.5;
  sizetype unwind_info_len.6;
  guint8 * D.24755;
  guint8 * p;
  int pos;
  int reg;
  int offset;
  int cfa_reg;
  int cfa_offset;

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

        p.2 = p;
        D.24725 = *p.2;
        D.24726 = (int) D.24725;
        op = D.24726 & 192;
        switch (op) <default: <D.24453>, case 0: <D.24444>, case 64: <D.24441>, case 128: <D.24443>>
        <D.24441>:
        p.2 = p;
        D.24725 = *p.2;
        D.24726 = (int) D.24725;
        D.24727 = D.24726 & 63;
        pos = D.24727 + pos;
        p.2 = p;
        p.3 = p.2 + 1;
        p = p.3;
        goto <D.24442>;
        <D.24443>:
        p.2 = p;
        D.24725 = *p.2;
        D.24726 = (int) D.24725;
        reg = D.24726 & 63;
        p.2 = p;
        p.3 = p.2 + 1;
        p = p.3;
        p.2 = p;
        D.24729 = decode_uleb128 (p.2, &p);
        D.24730 = D.24729 * 4294967292;
        offset = (int) D.24730;
        D.24731 = mono_hw_reg_to_dwarf_reg (14);
        if (D.24731 == reg) goto <D.24732>; else goto <D.24733>;
        <D.24732>:
        D.24734 = -offset;
        printf ("CFA: [%x] offset: %s at cfa-0x%x\n", pos, "pc", D.24734);
        goto <D.24735>;
        <D.24733>:
        D.24736 = mono_dwarf_reg_to_hw_reg (reg);
        D.24737 = mono_arch_regname (D.24736);
        D.24734 = -offset;
        printf ("CFA: [%x] offset: %s at cfa-0x%x\n", pos, D.24737, D.24734);
        <D.24735>:
        goto <D.24442>;
        <D.24444>:
        {
          int ext_op;

          p.2 = p;
          D.24725 = *p.2;
          ext_op = (int) D.24725;
          p.2 = p;
          p.3 = p.2 + 1;
          p = p.3;
          switch (ext_op) <default: <D.24452>, case 4: <D.24451>, case 12: <D.24446>, case 13: <D.24449>, case 14: <D.24448>, case 17: <D.24450>>
          <D.24446>:
          p.2 = p;
          D.24738 = decode_uleb128 (p.2, &p);
          cfa_reg = (int) D.24738;
          p.2 = p;
          D.24739 = decode_uleb128 (p.2, &p);
          cfa_offset = (int) D.24739;
          D.24740 = mono_dwarf_reg_to_hw_reg (cfa_reg);
          D.24741 = mono_arch_regname (D.24740);
          printf ("CFA: [%x] def_cfa: %s+0x%x\n", pos, D.24741, cfa_offset);
          goto <D.24447>;
          <D.24448>:
          p.2 = p;
          D.24742 = decode_uleb128 (p.2, &p);
          cfa_offset = (int) D.24742;
          printf ("CFA: [%x] def_cfa_offset: 0x%x\n", pos, cfa_offset);
          goto <D.24447>;
          <D.24449>:
          p.2 = p;
          D.24743 = decode_uleb128 (p.2, &p);
          cfa_reg = (int) D.24743;
          D.24744 = mono_dwarf_reg_to_hw_reg (cfa_reg);
          D.24745 = mono_arch_regname (D.24744);
          printf ("CFA: [%x] def_cfa_reg: %s\n", pos, D.24745);
          goto <D.24447>;
          <D.24450>:
          p.2 = p;
          D.24746 = decode_uleb128 (p.2, &p);
          reg = (int) D.24746;
          p.2 = p;
          D.24747 = decode_sleb128 (p.2, &p);
          offset = D.24747 * -4;
          D.24748 = mono_dwarf_reg_to_hw_reg (reg);
          D.24749 = mono_arch_regname (D.24748);
          D.24734 = -offset;
          printf ("CFA: [%x] offset_extended_sf: %s at cfa-0x%x\n", pos, D.24749, D.24734);
          goto <D.24447>;
          <D.24451>:
          p.2 = p;
          D.24750 = mono_read32 (p.2);
          pos.4 = (unsigned int) pos;
          D.24752 = D.24750 + pos.4;
          pos = (int) D.24752;
          p.2 = p;
          p.5 = p.2 + 4;
          p = p.5;
          goto <D.24447>;
          <D.24452>:
          monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "unwind.c", 306);
          <D.24447>:
          goto <D.24442>;
        }
        <D.24453>:
        monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "unwind.c", 311);
        <D.24442>:
      }
      <D.24455>:
      unwind_info_len.6 = (sizetype) unwind_info_len;
      D.24755 = unwind_info + unwind_info_len.6;
      p.2 = p;
      if (D.24755 > p.2) goto <D.24454>; else goto <D.24456>;
      <D.24456>:
    }
  finally
    {
      p = {CLOBBER};
    }
}


decode_uleb128 (guint8 * buf, guint8 * * endbuf)
{
  int D.24756;
  int D.24757;
  int D.24758;
  unsigned int D.24759;
  signed char b.7;
  guint32 D.24762;
  guint8 * p;
  guint32 res;
  int shift;

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

    b = *p;
    p = p + 1;
    D.24756 = (int) b;
    D.24757 = D.24756 & 127;
    D.24758 = D.24757 << shift;
    D.24759 = (unsigned int) D.24758;
    res = D.24759 | res;
    b.7 = (signed char) b;
    if (b.7 >= 0) goto <D.24418>; else goto <D.24761>;
    <D.24761>:
    shift = shift + 7;
  }
  goto <D.24419>;
  <D.24418>:
  *endbuf = p;
  D.24762 = res;
  return D.24762;
}


decode_sleb128 (guint8 * buf, guint8 * * endbuf)
{
  int D.24764;
  int D.24765;
  int D.24766;
  signed char b.8;
  int D.24772;
  int D.24775;
  int D.24776;
  gint32 D.24777;
  guint8 * p;
  gint32 res;
  int shift;

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

    b = *p;
    p = p + 1;
    D.24764 = (int) b;
    D.24765 = D.24764 & 127;
    D.24766 = D.24765 << shift;
    res = D.24766 | res;
    shift = shift + 7;
    b.8 = (signed char) b;
    if (b.8 >= 0) goto <D.24768>; else goto <D.24769>;
    <D.24768>:
    if (shift <= 31) goto <D.24770>; else goto <D.24771>;
    <D.24770>:
    D.24764 = (int) b;
    D.24772 = D.24764 & 64;
    if (D.24772 != 0) goto <D.24773>; else goto <D.24774>;
    <D.24773>:
    D.24775 = 1 << shift;
    D.24776 = -D.24775;
    res = D.24776 | res;
    <D.24774>:
    <D.24771>:
    goto <D.24428>;
    <D.24769>:
  }
  goto <D.24429>;
  <D.24428>:
  *endbuf = p;
  D.24777 = res;
  return D.24777;
}


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

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


mono_unwind_ops_encode (struct GSList * unwind_ops, guint32 * out_len)
{
  short unsigned int D.24781;
  int D.24782;
  unsigned int D.24783;
  unsigned int loc.9;
  unsigned int D.24785;
  guint8 * p.10;
  guint8 * p.11;
  guint8 * p.12;
  unsigned char D.24791;
  unsigned char D.24792;
  unsigned char D.24793;
  unsigned char D.24794;
  guint8 * p.13;
  guint8 * p.14;
  unsigned char D.24798;
  int D.24799;
  guint8 * p.15;
  guint8 * p.16;
  unsigned int reg.17;
  int D.24803;
  unsigned int D.24804;
  guint8 * p.18;
  guint8 * p.19;
  guint8 * p.20;
  guint8 * p.21;
  guint8 * p.22;
  guint8 * p.23;
  int D.24813;
  guint8 * p.24;
  guint8 * p.25;
  signed char D.24817;
  signed char D.24818;
  unsigned char D.24819;
  unsigned int D.24820;
  int p.26;
  int buf.27;
  int D.24823;
  _Bool D.24824;
  long int D.24825;
  long int D.24826;
  unsigned int D.24829;
  unsigned int D.24830;
  unsigned int D.24831;
  guint8 * D.24832;
  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.24478>;
      <D.24477>:
      {
        int reg;

        op = l->data;
        D.24781 = op->reg;
        D.24782 = (int) D.24781;
        reg = mono_hw_reg_to_dwarf_reg (D.24782);
        goto <D.24469>;
        <D.24468>:
        D.24783 = op->when;
        loc.9 = (unsigned int) loc;
        D.24785 = D.24783 - loc.9;
        if (D.24785 <= 31) goto <D.24786>; else goto <D.24787>;
        <D.24786>:
        p.10 = p;
        p.11 = p.10;
        p.12 = p.11 + 1;
        p = p.12;
        D.24783 = op->when;
        D.24791 = (unsigned char) D.24783;
        D.24792 = (unsigned char) loc;
        D.24793 = D.24791 - D.24792;
        D.24794 = D.24793 | 64;
        *p.11 = D.24794;
        D.24783 = op->when;
        loc = (int) D.24783;
        goto <D.24795>;
        <D.24787>:
        p.10 = p;
        p.13 = p.10;
        p.14 = p.13 + 1;
        p = p.14;
        *p.13 = 94;
        loc = loc + 30;
        <D.24795>:
        <D.24469>:
        D.24783 = op->when;
        loc.9 = (unsigned int) loc;
        if (D.24783 > loc.9) goto <D.24468>; else goto <D.24470>;
        <D.24470>:
        D.24798 = op->op;
        D.24799 = (int) D.24798;
        switch (D.24799) <default: <D.24476>, case 12: <D.24471>, case 13: <D.24474>, case 14: <D.24473>, case 128: <D.24475>>
        <D.24471>:
        p.10 = p;
        p.15 = p.10;
        p.16 = p.15 + 1;
        p = p.16;
        D.24798 = op->op;
        *p.15 = D.24798;
        reg.17 = (unsigned int) reg;
        p.10 = p;
        encode_uleb128 (reg.17, p.10, &p);
        D.24803 = op->val;
        D.24804 = (unsigned int) D.24803;
        p.10 = p;
        encode_uleb128 (D.24804, p.10, &p);
        goto <D.24472>;
        <D.24473>:
        p.10 = p;
        p.18 = p.10;
        p.19 = p.18 + 1;
        p = p.19;
        D.24798 = op->op;
        *p.18 = D.24798;
        D.24803 = op->val;
        D.24804 = (unsigned int) D.24803;
        p.10 = p;
        encode_uleb128 (D.24804, p.10, &p);
        goto <D.24472>;
        <D.24474>:
        p.10 = p;
        p.20 = p.10;
        p.21 = p.20 + 1;
        p = p.21;
        D.24798 = op->op;
        *p.20 = D.24798;
        reg.17 = (unsigned int) reg;
        p.10 = p;
        encode_uleb128 (reg.17, p.10, &p);
        goto <D.24472>;
        <D.24475>:
        if (reg > 63) goto <D.24809>; else goto <D.24810>;
        <D.24809>:
        p.10 = p;
        p.22 = p.10;
        p.23 = p.22 + 1;
        p = p.23;
        *p.22 = 17;
        reg.17 = (unsigned int) reg;
        p.10 = p;
        encode_uleb128 (reg.17, p.10, &p);
        D.24803 = op->val;
        D.24813 = D.24803 / -4;
        p.10 = p;
        encode_sleb128 (D.24813, p.10, &p);
        goto <D.24814>;
        <D.24810>:
        p.10 = p;
        p.24 = p.10;
        p.25 = p.24 + 1;
        p = p.25;
        D.24817 = (signed char) reg;
        D.24818 = D.24817 | -128;
        D.24819 = (unsigned char) D.24818;
        *p.24 = D.24819;
        D.24803 = op->val;
        D.24813 = D.24803 / -4;
        D.24820 = (unsigned int) D.24813;
        p.10 = p;
        encode_uleb128 (D.24820, p.10, &p);
        <D.24814>:
        goto <D.24472>;
        <D.24476>:
        monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "unwind.c", 378);
        <D.24472>:
      }
      l = l->next;
      <D.24478>:
      if (l != 0B) goto <D.24477>; else goto <D.24479>;
      <D.24479>:
      p.10 = p;
      p.26 = (int) p.10;
      buf.27 = (int) buf;
      D.24823 = p.26 - buf.27;
      D.24824 = D.24823 > 4095;
      D.24825 = (long int) D.24824;
      D.24826 = __builtin_expect (D.24825, 0);
      if (D.24826 != 0) goto <D.24827>; else goto <D.24828>;
      <D.24827>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "unwind.c", 383, "p - buf < 4096");
      <D.24828>:
      p.10 = p;
      p.26 = (int) p.10;
      buf.27 = (int) buf;
      D.24823 = p.26 - buf.27;
      D.24829 = (unsigned int) D.24823;
      *out_len = D.24829;
      p.10 = p;
      p.26 = (int) p.10;
      buf.27 = (int) buf;
      D.24823 = p.26 - buf.27;
      D.24830 = (unsigned int) D.24823;
      res = monoeg_malloc (D.24830);
      p.10 = p;
      p.26 = (int) p.10;
      buf.27 = (int) buf;
      D.24823 = p.26 - buf.27;
      D.24831 = (unsigned int) D.24823;
      memcpy (res, buf, D.24831);
      monoeg_g_free (buf);
      D.24832 = res;
      return D.24832;
    }
  finally
    {
      p = {CLOBBER};
    }
}


encode_sleb128 (gint32 value, guint8 * buf, guint8 * * endbuf)
{
  _Bool D.24835;
  unsigned char D.24836;
  unsigned int D.24839;
  int D.24840;
  int D.24841;
  int D.24842;
  int D.24848;
  int D.24849;
  guint8 * p.28;
  gboolean more;
  gboolean negative;
  guint32 size;
  guint8 byte;
  guint8 * p;

  more = 1;
  D.24835 = value < 0;
  negative = (gboolean) D.24835;
  size = 32;
  p = buf;
  goto <D.24408>;
  <D.24407>:
  D.24836 = (unsigned char) value;
  byte = D.24836 & 127;
  value = value >> 7;
  if (negative != 0) goto <D.24837>; else goto <D.24838>;
  <D.24837>:
  D.24839 = size + 4294967289;
  D.24840 = (int) D.24839;
  D.24841 = 1 << D.24840;
  D.24842 = -D.24841;
  value = D.24842 | value;
  <D.24838>:
  if (value == 0) goto <D.24847>; else goto <D.24843>;
  <D.24847>:
  D.24848 = (int) byte;
  D.24849 = D.24848 & 64;
  if (D.24849 == 0) goto <D.24844>; else goto <D.24843>;
  <D.24843>:
  if (value == -1) goto <D.24850>; else goto <D.24845>;
  <D.24850>:
  D.24848 = (int) byte;
  D.24849 = D.24848 & 64;
  if (D.24849 != 0) goto <D.24844>; else goto <D.24845>;
  <D.24844>:
  more = 0;
  goto <D.24846>;
  <D.24845>:
  byte = byte | 128;
  <D.24846>:
  p.28 = p;
  p = p.28 + 1;
  *p.28 = byte;
  <D.24408>:
  if (more != 0) goto <D.24407>; else goto <D.24409>;
  <D.24409>:
  *endbuf = p;
}


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

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

    D.24852 = (unsigned char) value;
    b = D.24852 & 127;
    value = value >> 7;
    if (value != 0) goto <D.24853>; else goto <D.24854>;
    <D.24853>:
    b = b | 128;
    <D.24854>:
    p.29 = p;
    p = p.29 + 1;
    *p.29 = b;
  }
  if (value != 0) goto <D.24395>; else goto <D.24396>;
  <D.24396>:
  *endbuf = p;
}


memcpy (void * restrict __dest, const void * restrict __src, size_t __len)
{
  void * D.24856;
  unsigned int D.24857;

  D.24857 = __builtin_object_size (__dest, 0);
  D.24856 = __builtin___memcpy_chk (__dest, __src, __len, D.24857);
  return D.24856;
}


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.30;
  unsigned char D.24860;
  int D.24861;
  int D.24862;
  guint8 * p.31;
  unsigned int D.24864;
  unsigned int D.24865;
  int D.24866;
  unsigned int D.24867;
  unsigned int D.24868;
  unsigned int D.24869;
  unsigned int D.24870;
  unsigned int D.24871;
  _Bool D.24872;
  long int D.24873;
  long int D.24874;
  int D.24877;
  unsigned int D.24878;
  unsigned int D.24879;
  unsigned int D.24882;
  unsigned int pos.32;
  unsigned int D.24884;
  guint8 * p.33;
  int ip.34;
  int start_ip.35;
  int D.24888;
  guint8 * D.24890;
  unsigned int save_locations_len.36;
  unsigned int D.24894;
  int D.24895;
  unsigned int D.24896;
  unsigned int D.24897;
  mgreg_t * D.24898;
  int D.24899;
  sizetype D.24900;
  sizetype cfa_offset.37;
  sizetype D.24902;
  unsigned char D.24903;
  <unnamed type> D.24906;
  _Bool D.24909;
  long int D.24910;
  long int D.24911;
  unsigned int hreg.38;
  unsigned int D.24915;
  mgreg_t * D.24916;
  int D.24917;
  sizetype D.24918;
  mgreg_t * D.24919;
  int D.24920;
  _Bool D.24921;
  _Bool D.24922;
  _Bool D.24923;
  mgreg_t * * D.24926;
  struct Loc locations[272];
  guint8 reg_saved[272];
  int i;
  int pos;
  int reg;
  int cfa_reg;
  int cfa_offset;
  int offset;
  guint8 * p;
  guint8 * cfa_val;

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

        p.30 = p;
        D.24860 = *p.30;
        D.24861 = (int) D.24860;
        op = D.24861 & 192;
        switch (op) <default: <D.24528>, case 0: <D.24518>, case 64: <D.24515>, case 128: <D.24517>>
        <D.24515>:
        p.30 = p;
        D.24860 = *p.30;
        D.24861 = (int) D.24860;
        D.24862 = D.24861 & 63;
        pos = D.24862 + pos;
        p.30 = p;
        p.31 = p.30 + 1;
        p = p.31;
        goto <D.24516>;
        <D.24517>:
        p.30 = p;
        D.24860 = *p.30;
        D.24861 = (int) D.24860;
        reg = D.24861 & 63;
        p.30 = p;
        p.31 = p.30 + 1;
        p = p.31;
        reg_saved[reg] = 1;
        locations[reg].loc_type = 1;
        p.30 = p;
        D.24864 = decode_uleb128 (p.30, &p);
        D.24865 = D.24864 * 4294967292;
        D.24866 = (int) D.24865;
        locations[reg].offset = D.24866;
        goto <D.24516>;
        <D.24518>:
        {
          int ext_op;

          p.30 = p;
          D.24860 = *p.30;
          ext_op = (int) D.24860;
          p.30 = p;
          p.31 = p.30 + 1;
          p = p.31;
          switch (ext_op) <default: <D.24527>, case 4: <D.24526>, case 5: <D.24525>, case 12: <D.24520>, case 13: <D.24523>, case 14: <D.24522>, case 17: <D.24524>>
          <D.24520>:
          p.30 = p;
          D.24867 = decode_uleb128 (p.30, &p);
          cfa_reg = (int) D.24867;
          p.30 = p;
          D.24868 = decode_uleb128 (p.30, &p);
          cfa_offset = (int) D.24868;
          goto <D.24521>;
          <D.24522>:
          p.30 = p;
          D.24869 = decode_uleb128 (p.30, &p);
          cfa_offset = (int) D.24869;
          goto <D.24521>;
          <D.24523>:
          p.30 = p;
          D.24870 = decode_uleb128 (p.30, &p);
          cfa_reg = (int) D.24870;
          goto <D.24521>;
          <D.24524>:
          p.30 = p;
          D.24871 = decode_uleb128 (p.30, &p);
          reg = (int) D.24871;
          p.30 = p;
          offset = decode_sleb128 (p.30, &p);
          D.24872 = reg > 271;
          D.24873 = (long int) D.24872;
          D.24874 = __builtin_expect (D.24873, 0);
          if (D.24874 != 0) goto <D.24875>; else goto <D.24876>;
          <D.24875>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "unwind.c", 470, "reg < NUM_REGS");
          <D.24876>:
          reg_saved[reg] = 1;
          locations[reg].loc_type = 1;
          D.24877 = offset * -4;
          locations[reg].offset = D.24877;
          goto <D.24521>;
          <D.24525>:
          p.30 = p;
          D.24878 = decode_uleb128 (p.30, &p);
          reg = (int) D.24878;
          p.30 = p;
          D.24879 = decode_uleb128 (p.30, &p);
          offset = (int) D.24879;
          D.24872 = reg > 271;
          D.24873 = (long int) D.24872;
          D.24874 = __builtin_expect (D.24873, 0);
          if (D.24874 != 0) goto <D.24880>; else goto <D.24881>;
          <D.24880>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "unwind.c", 478, "reg < NUM_REGS");
          <D.24881>:
          reg_saved[reg] = 1;
          locations[reg].loc_type = 1;
          D.24877 = offset * -4;
          locations[reg].offset = D.24877;
          goto <D.24521>;
          <D.24526>:
          p.30 = p;
          D.24882 = mono_read32 (p.30);
          pos.32 = (unsigned int) pos;
          D.24884 = D.24882 + pos.32;
          pos = (int) D.24884;
          p.30 = p;
          p.33 = p.30 + 4;
          p = p.33;
          goto <D.24521>;
          <D.24527>:
          monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "unwind.c", 488);
          <D.24521>:
          goto <D.24516>;
        }
        <D.24528>:
        monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "unwind.c", 493);
        <D.24516>:
      }
      <D.24530>:
      ip.34 = (int) ip;
      start_ip.35 = (int) start_ip;
      D.24888 = ip.34 - start_ip.35;
      if (D.24888 >= pos) goto <D.24889>; else goto <D.24531>;
      <D.24889>:
      D.24890 = unwind_info + unwind_info_len;
      p.30 = p;
      if (D.24890 > p.30) goto <D.24529>; else goto <D.24531>;
      <D.24531>:
      if (save_locations != 0B) goto <D.24891>; else goto <D.24892>;
      <D.24891>:
      save_locations_len.36 = (unsigned int) save_locations_len;
      D.24894 = save_locations_len.36 * 4;
      memset (save_locations, 0, D.24894);
      <D.24892>:
      D.24895 = mono_dwarf_reg_to_hw_reg (cfa_reg);
      D.24896 = (unsigned int) D.24895;
      D.24897 = D.24896 * 4;
      D.24898 = regs + D.24897;
      D.24899 = *D.24898;
      D.24900 = (sizetype) D.24899;
      cfa_offset.37 = (sizetype) cfa_offset;
      D.24902 = D.24900 + cfa_offset.37;
      cfa_val = (guint8 *) D.24902;
      i = 0;
      goto <D.24534>;
      <D.24533>:
      D.24903 = reg_saved[i];
      if (D.24903 != 0) goto <D.24904>; else goto <D.24905>;
      <D.24904>:
      D.24906 = locations[i].loc_type;
      if (D.24906 == 1) goto <D.24907>; else goto <D.24908>;
      <D.24907>:
      {
        int hreg;

        hreg = mono_dwarf_reg_to_hw_reg (i);
        D.24909 = hreg >= nregs;
        D.24910 = (long int) D.24909;
        D.24911 = __builtin_expect (D.24910, 0);
        if (D.24911 != 0) goto <D.24912>; else goto <D.24913>;
        <D.24912>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "unwind.c", 504, "hreg < nregs");
        <D.24913>:
        hreg.38 = (unsigned int) hreg;
        D.24915 = hreg.38 * 4;
        D.24916 = regs + D.24915;
        D.24917 = locations[i].offset;
        D.24918 = (sizetype) D.24917;
        D.24919 = cfa_val + D.24918;
        D.24920 = *D.24919;
        *D.24916 = D.24920;
        D.24921 = save_locations != 0B;
        D.24922 = hreg < save_locations_len;
        D.24923 = D.24921 & D.24922;
        if (D.24923 != 0) goto <D.24924>; else goto <D.24925>;
        <D.24924>:
        hreg.38 = (unsigned int) hreg;
        D.24915 = hreg.38 * 4;
        D.24926 = save_locations + D.24915;
        D.24917 = locations[i].offset;
        D.24918 = (sizetype) D.24917;
        D.24919 = cfa_val + D.24918;
        *D.24926 = D.24919;
        <D.24925>:
      }
      <D.24908>:
      <D.24905>:
      i = i + 1;
      <D.24534>:
      if (i <= 271) goto <D.24533>; else goto <D.24535>;
      <D.24535>:
      *out_cfa = cfa_val;
    }
  finally
    {
      locations = {CLOBBER};
      reg_saved = {CLOBBER};
      p = {CLOBBER};
    }
}


memset (void * __dest, int __ch, size_t __len)
{
  int D.24929;
  int D.24934;
  void * D.24936;
  unsigned int D.24937;

  D.24929 = __builtin_constant_p (__len);
  if (D.24929 != 0) goto <D.24930>; else goto <D.24931>;
  <D.24930>:
  if (__len == 0) goto <D.24932>; else goto <D.24933>;
  <D.24932>:
  D.24934 = __builtin_constant_p (__ch);
  if (D.24934 == 0) goto <D.24927>; else goto <D.24935>;
  <D.24935>:
  if (__ch != 0) goto <D.24927>; else goto <D.24928>;
  <D.24927>:
  __warn_memset_zero_len ();
  D.24936 = __dest;
  return D.24936;
  <D.24928>:
  <D.24933>:
  <D.24931>:
  D.24937 = __builtin_object_size (__dest, 0);
  D.24936 = __builtin___memset_chk (__dest, __ch, __len, D.24937);
  return D.24936;
}


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


mono_unwind_cleanup ()
{
  struct MonoUnwindInfo * * cached_info.39;
  unsigned int i.40;
  unsigned int D.24943;
  struct MonoUnwindInfo * * D.24944;
  int cached_info_next.41;
  int i;

  DeleteCriticalSection (&unwind_mutex);
  cached_info.39 = cached_info;
  if (cached_info.39 == 0B) goto <D.24940>; else goto <D.24941>;
  <D.24940>:
  return;
  <D.24941>:
  i = 0;
  goto <D.24545>;
  <D.24544>:
  {
    struct MonoUnwindInfo * cached;

    cached_info.39 = cached_info;
    i.40 = (unsigned int) i;
    D.24943 = i.40 * 4;
    D.24944 = cached_info.39 + D.24943;
    cached = *D.24944;
    monoeg_g_free (cached);
  }
  i = i + 1;
  <D.24545>:
  cached_info_next.41 = cached_info_next;
  if (i < cached_info_next.41) goto <D.24544>; else goto <D.24546>;
  <D.24546>:
  cached_info.39 = cached_info;
  monoeg_g_free (cached_info.39);
}


mono_cache_unwind_info (guint8 * unwind_info, guint32 unwind_info_len)
{
  _Bool D.24949;
  long int D.24950;
  long int D.24951;
  struct MonoUnwindInfo * * cached_info.42;
  int cached_info_size.43;
  unsigned int cached_info_size.44;
  unsigned int D.24959;
  void * cached_info.45;
  unsigned int i.46;
  unsigned int D.24962;
  struct MonoUnwindInfo * * D.24963;
  unsigned int D.24964;
  guint8[0:] * D.24967;
  int D.24968;
  _Bool D.24973;
  long int D.24974;
  long int D.24975;
  guint32 D.24978;
  int cached_info_next.47;
  unsigned int D.24980;
  guint8[0:] * D.24981;
  unsigned int D.24984;
  struct GSList * cached_info_list.48;
  struct GSList * cached_info_list.49;
  int cached_info_size.50;
  int cached_info_next.51;
  int cached_info_next.52;
  unsigned int cached_info_next.53;
  unsigned int D.24991;
  struct MonoUnwindInfo * * D.24992;
  int unwind_info_size.54;
  unsigned int unwind_info_size.55;
  unsigned int D.24995;
  unsigned int D.24996;
  int unwind_info_size.56;
  _Bool D.25000;
  long int D.25001;
  long int D.25002;
  int i;
  struct MonoUnwindInfo * info;

  {
    int ret;

    ret = pthread_mutex_lock (&unwind_mutex.mutex);
    if (ret != 0) goto <D.24947>; else goto <D.24948>;
    <D.24947>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
    <D.24948>:
    D.24949 = ret != 0;
    D.24950 = (long int) D.24949;
    D.24951 = __builtin_expect (D.24950, 0);
    if (D.24951 != 0) goto <D.24952>; else goto <D.24953>;
    <D.24952>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "unwind.c", 557, "ret == 0");
    <D.24953>:
  }
  cached_info.42 = cached_info;
  if (cached_info.42 == 0B) goto <D.24955>; else goto <D.24956>;
  <D.24955>:
  cached_info_size = 16;
  cached_info_size.43 = cached_info_size;
  cached_info_size.44 = (unsigned int) cached_info_size.43;
  D.24959 = cached_info_size.44 * 4;
  cached_info.45 = monoeg_malloc0 (D.24959);
  cached_info = cached_info.45;
  <D.24956>:
  i = 0;
  goto <D.24557>;
  <D.24556>:
  {
    struct MonoUnwindInfo * cached;

    cached_info.42 = cached_info;
    i.46 = (unsigned int) i;
    D.24962 = i.46 * 4;
    D.24963 = cached_info.42 + D.24962;
    cached = *D.24963;
    D.24964 = cached->len;
    if (D.24964 == unwind_info_len) goto <D.24965>; else goto <D.24966>;
    <D.24965>:
    D.24967 = &cached->info;
    D.24968 = memcmp (D.24967, unwind_info, unwind_info_len);
    if (D.24968 == 0) goto <D.24969>; else goto <D.24970>;
    <D.24969>:
    {
      int ret;

      ret = pthread_mutex_unlock (&unwind_mutex.mutex);
      if (ret != 0) goto <D.24971>; else goto <D.24972>;
      <D.24971>:
      monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
      <D.24972>:
      D.24973 = ret != 0;
      D.24974 = (long int) D.24973;
      D.24975 = __builtin_expect (D.24974, 0);
      if (D.24975 != 0) goto <D.24976>; else goto <D.24977>;
      <D.24976>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "unwind.c", 568, "ret == 0");
      <D.24977>:
    }
    D.24978 = (guint32) i;
    return D.24978;
    <D.24970>:
    <D.24966>:
  }
  i = i + 1;
  <D.24557>:
  cached_info_next.47 = cached_info_next;
  if (i < cached_info_next.47) goto <D.24556>; else goto <D.24558>;
  <D.24558>:
  D.24980 = unwind_info_len + 4;
  info = monoeg_malloc (D.24980);
  info->len = unwind_info_len;
  D.24981 = &info->info;
  memcpy (D.24981, unwind_info, unwind_info_len);
  i = cached_info_next;
  cached_info_next.47 = cached_info_next;
  cached_info_size.43 = cached_info_size;
  if (cached_info_next.47 >= cached_info_size.43) goto <D.24982>; else goto <D.24983>;
  <D.24982>:
  {
    struct MonoUnwindInfo * * old_table;
    struct MonoUnwindInfo * * new_table;

    old_table = cached_info;
    cached_info_size.43 = cached_info_size;
    cached_info_size.44 = (unsigned int) cached_info_size.43;
    D.24984 = cached_info_size.44 * 8;
    new_table = monoeg_malloc0 (D.24984);
    cached_info.42 = cached_info;
    cached_info_size.43 = cached_info_size;
    cached_info_size.44 = (unsigned int) cached_info_size.43;
    D.24959 = cached_info_size.44 * 4;
    memcpy (new_table, cached_info.42, D.24959);
    mono_memory_barrier ();
    cached_info = new_table;
    cached_info_list.48 = cached_info_list;
    cached_info.42 = cached_info;
    cached_info_list.49 = monoeg_g_slist_prepend (cached_info_list.48, cached_info.42);
    cached_info_list = cached_info_list.49;
    cached_info_size.43 = cached_info_size;
    cached_info_size.50 = cached_info_size.43 * 2;
    cached_info_size = cached_info_size.50;
  }
  <D.24983>:
  cached_info.42 = cached_info;
  cached_info_next.47 = cached_info_next;
  cached_info_next.51 = cached_info_next.47;
  cached_info_next.52 = cached_info_next.51 + 1;
  cached_info_next = cached_info_next.52;
  cached_info_next.53 = (unsigned int) cached_info_next.51;
  D.24991 = cached_info_next.53 * 4;
  D.24992 = cached_info.42 + D.24991;
  *D.24992 = info;
  unwind_info_size.54 = unwind_info_size;
  unwind_info_size.55 = (unsigned int) unwind_info_size.54;
  D.24995 = unwind_info_len + unwind_info_size.55;
  D.24996 = D.24995 + 4;
  unwind_info_size.56 = (int) D.24996;
  unwind_info_size = unwind_info_size.56;
  {
    int ret;

    ret = pthread_mutex_unlock (&unwind_mutex.mutex);
    if (ret != 0) goto <D.24998>; else goto <D.24999>;
    <D.24998>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.24999>:
    D.25000 = ret != 0;
    D.25001 = (long int) D.25000;
    D.25002 = __builtin_expect (D.25001, 0);
    if (D.25002 != 0) goto <D.25003>; else goto <D.25004>;
    <D.25003>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "unwind.c", 605, "ret == 0");
    <D.25004>:
  }
  D.24978 = (guint32) i;
  return D.24978;
}


mono_get_cached_unwind_info (guint32 index, guint32 * unwind_info_len)
{
  unsigned int D.25006;
  struct MonoUnwindInfo * * D.25007;
  unsigned int D.25008;
  guint8 * D.25009;
  struct MonoUnwindInfo * * table;
  struct MonoUnwindInfo * info;
  guint8 * data;

  table = cached_info;
  D.25006 = index * 4;
  D.25007 = table + D.25006;
  info = *D.25007;
  D.25008 = info->len;
  *unwind_info_len = D.25008;
  data = &info->info;
  D.25009 = data;
  return D.25009;
}


mono_unwind_get_dwarf_data_align ()
{
  int D.25011;

  D.25011 = -4;
  return D.25011;
}


mono_unwind_get_dwarf_pc_reg ()
{
  int D.25013;

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


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.57;
  unsigned int D.25016;
  unsigned int fde_len.58;
  unsigned int D.25018;
  _Bool D.25019;
  long int D.25020;
  long int D.25021;
  guint8 * p.59;
  sizetype cie_offset.60;
  sizetype D.25026;
  _Bool D.25027;
  long int D.25028;
  long int D.25029;
  unsigned char D.25032;
  _Bool D.25033;
  long int D.25034;
  long int D.25035;
  guint8 * p.61;
  unsigned int D.25039;
  sizetype D.25040;
  guint8 * p.62;
  unsigned int D.25042;
  unsigned int D.25043;
  char * D.25044;
  unsigned int D.25047;
  sizetype i.63;
  char * D.25049;
  char D.25050;
  int D.25051;
  unsigned char D.25052;
  _Bool D.25053;
  long int D.25054;
  long int D.25055;
  _Bool D.25058;
  long int D.25059;
  long int D.25060;
  sizetype cie_aug_len.64;
  guint8 * p.65;
  sizetype pc_begin.66;
  unsigned int D.25068;
  sizetype aug_len.67;
  guint8 * p.68;
  sizetype fde_len.69;
  sizetype D.25073;
  guint8 * D.25074;
  int D.25075;
  int p.70;
  unsigned int pc_range.71;
  unsigned int D.25086;
  long long int D.25090;
  sizetype lsda_offset.72;
  _Bool D.25095;
  long int D.25096;
  long int D.25097;
  _Bool D.25100;
  long int D.25101;
  long int D.25102;
  int D.25105;
  _Bool D.25106;
  long int D.25107;
  long int D.25108;
  sizetype cie_len.73;
  sizetype D.25112;
  guint8 * D.25113;
  int D.25114;
  int cie_cfi.74;
  int D.25116;
  int fde_cfi.75;
  int D.25118;
  unsigned int buf_len.76;
  guint8 * D.25121;
  int D.25122;
  unsigned int D.25123;
  int D.25125;
  unsigned int D.25126;
  _Bool D.25127;
  long int D.25128;
  long int D.25129;
  unsigned int i.77;
  guint8 * D.25133;
  unsigned int i.78;
  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.57 = p;
      D.25016 = MEM[(guint32 *)p.57];
      fde_len = (gint32) D.25016;
      fde_len.58 = (unsigned int) fde_len;
      D.25018 = fde_len.58 + 1;
      D.25019 = D.25018 <= 1;
      D.25020 = (long int) D.25019;
      D.25021 = __builtin_expect (D.25020, 0);
      if (D.25021 != 0) goto <D.25022>; else goto <D.25023>;
      <D.25022>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "unwind.c", 833, "fde_len != 0xffffffff && fde_len != 0");
      <D.25023>:
      p.57 = p;
      p.59 = p.57 + 4;
      p = p.59;
      p.57 = p;
      D.25016 = MEM[(guint32 *)p.57];
      cie_offset = (gint32) D.25016;
      p.57 = p;
      cie_offset.60 = (sizetype) cie_offset;
      D.25026 = -cie_offset.60;
      cie = p.57 + D.25026;
      p.57 = p;
      p.59 = p.57 + 4;
      p = p.59;
      fde_current = p;
      p = cie;
      p.57 = p;
      D.25016 = MEM[(guint32 *)p.57];
      cie_len = (gint32) D.25016;
      p.57 = p;
      p.59 = p.57 + 4;
      p = p.59;
      p.57 = p;
      D.25016 = MEM[(guint32 *)p.57];
      cie_id = (gint32) D.25016;
      D.25027 = cie_id != 0;
      D.25028 = (long int) D.25027;
      D.25029 = __builtin_expect (D.25028, 0);
      if (D.25029 != 0) goto <D.25030>; else goto <D.25031>;
      <D.25030>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "unwind.c", 845, "cie_id == 0");
      <D.25031>:
      p.57 = p;
      p.59 = p.57 + 4;
      p = p.59;
      p.57 = p;
      D.25032 = *p.57;
      cie_version = (gint32) D.25032;
      D.25033 = cie_version != 1;
      D.25034 = (long int) D.25033;
      D.25035 = __builtin_expect (D.25034, 0);
      if (D.25035 != 0) goto <D.25036>; else goto <D.25037>;
      <D.25036>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "unwind.c", 848, "cie_version == 1");
      <D.25037>:
      p.57 = p;
      p.61 = p.57 + 1;
      p = p.61;
      cie_aug_str = p;
      p.57 = p;
      D.25039 = strlen (cie_aug_str);
      D.25040 = D.25039 + 1;
      p.62 = p.57 + D.25040;
      p = p.62;
      p.57 = p;
      D.25042 = decode_uleb128 (p.57, &p);
      code_align = (gint32) D.25042;
      p.57 = p;
      data_align = decode_sleb128 (p.57, &p);
      p.57 = p;
      D.25043 = decode_uleb128 (p.57, &p);
      return_reg = (gint32) D.25043;
      D.25044 = __builtin_strchr (cie_aug_str, 122);
      if (D.25044 != 0B) goto <D.25045>; else goto <D.25046>;
      <D.25045>:
      {
        guint8 * cie_aug;
        guint32 p_encoding;

        p.57 = p;
        D.25047 = decode_uleb128 (p.57, &p);
        cie_aug_len = (gint32) D.25047;
        has_fde_augmentation = 1;
        cie_aug = p;
        i = 0;
        goto <D.24672>;
        <D.24671>:
        i.63 = (sizetype) i;
        D.25049 = cie_aug_str + i.63;
        D.25050 = *D.25049;
        D.25051 = (int) D.25050;
        switch (D.25051) <default: <D.24670>, case 76: <D.24668>, case 80: <D.24667>, case 82: <D.24669>, case 122: <D.24665>>
        <D.24665>:
        goto <D.24666>;
        <D.24667>:
        p.57 = p;
        D.25032 = *p.57;
        p_encoding = (guint32) D.25032;
        p.57 = p;
        p.61 = p.57 + 1;
        p = p.61;
        p.57 = p;
        read_encoded_val (p_encoding, p.57, &p);
        goto <D.24666>;
        <D.24668>:
        p.57 = p;
        D.25032 = *p.57;
        D.25052 = D.25032 + 229;
        D.25053 = D.25052 > 1;
        D.25054 = (long int) D.25053;
        D.25055 = __builtin_expect (D.25054, 0);
        if (D.25055 != 0) goto <D.25056>; else goto <D.25057>;
        <D.25056>:
        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.25057>:
        p.57 = p;
        p.61 = p.57 + 1;
        p = p.61;
        goto <D.24666>;
        <D.24669>:
        p.57 = p;
        D.25032 = *p.57;
        D.25058 = D.25032 != 27;
        D.25059 = (long int) D.25058;
        D.25060 = __builtin_expect (D.25059, 0);
        if (D.25060 != 0) goto <D.25061>; else goto <D.25062>;
        <D.25061>:
        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.25062>:
        p.57 = p;
        p.61 = p.57 + 1;
        p = p.61;
        goto <D.24666>;
        <D.24670>:
        monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "unwind.c", 882);
        <D.24666>:
        i = i + 1;
        <D.24672>:
        i.63 = (sizetype) i;
        D.25049 = cie_aug_str + i.63;
        D.25050 = *D.25049;
        if (D.25050 != 0) goto <D.24671>; else goto <D.24673>;
        <D.24673>:
        p = cie_aug;
        p.57 = p;
        cie_aug_len.64 = (sizetype) cie_aug_len;
        p.65 = p.57 + cie_aug_len.64;
        p = p.65;
      }
      <D.25046>:
      cie_cfi = p;
      p = fde_current;
      p.57 = p;
      pc_begin = MEM[(gint32 *)p.57];
      p.57 = p;
      pc_begin.66 = (sizetype) pc_begin;
      code = p.57 + pc_begin.66;
      p.57 = p;
      p.59 = p.57 + 4;
      p = p.59;
      p.57 = p;
      D.25016 = MEM[(guint32 *)p.57];
      pc_range = (gint32) D.25016;
      p.57 = p;
      p.59 = p.57 + 4;
      p = p.59;
      if (has_fde_augmentation != 0) goto <D.25066>; else goto <D.25067>;
      <D.25066>:
      p.57 = p;
      D.25068 = decode_uleb128 (p.57, &p);
      aug_len = (gint32) D.25068;
      fde_aug = p;
      p.57 = p;
      aug_len.67 = (sizetype) aug_len;
      p.68 = p.57 + aug_len.67;
      p = p.68;
      goto <D.25071>;
      <D.25067>:
      aug_len = 0;
      <D.25071>:
      fde_cfi = p;
      fde_len.69 = (sizetype) fde_len;
      D.25073 = fde_len.69 + 4;
      D.25074 = fde + D.25073;
      D.25075 = (int) D.25074;
      p.57 = p;
      p.70 = (int) p.57;
      fde_data_len = D.25075 - p.70;
      if (code_len != 0B) goto <D.25077>; else goto <D.25078>;
      <D.25077>:
      pc_range.71 = (unsigned int) pc_range;
      *code_len = pc_range.71;
      <D.25078>:
      if (ex_info != 0B) goto <D.25080>; else goto <D.25081>;
      <D.25080>:
      *ex_info = 0B;
      *ex_info_len = 0;
      <D.25081>:
      if (aug_len != 0) goto <D.25082>; else goto <D.25083>;
      <D.25082>:
      {
        gint32 lsda_offset;
        guint8 * lsda;

        if (aug_len == 4) goto <D.25084>; else goto <D.25085>;
        <D.25084>:
        D.25086 = mono_read32 (fde_aug);
        lsda_offset = (gint32) D.25086;
        goto <D.25087>;
        <D.25085>:
        if (aug_len == 8) goto <D.25088>; else goto <D.25089>;
        <D.25088>:
        D.25090 = MEM[(gint64 *)fde_aug];
        lsda_offset = (gint32) D.25090;
        goto <D.25091>;
        <D.25089>:
        monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "unwind.c", 929);
        <D.25091>:
        <D.25087>:
        if (lsda_offset != 0) goto <D.25092>; else goto <D.25093>;
        <D.25092>:
        lsda_offset.72 = (sizetype) lsda_offset;
        lsda = fde_aug + lsda_offset.72;
        decode_lsda (lsda, code, ex_info, ex_info_len, type_info, this_reg, this_offset);
        <D.25093>:
      }
      <D.25083>:
      D.25095 = code_align != 1;
      D.25096 = (long int) D.25095;
      D.25097 = __builtin_expect (D.25096, 0);
      if (D.25097 != 0) goto <D.25098>; else goto <D.25099>;
      <D.25098>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "unwind.c", 938, "code_align == 1");
      <D.25099>:
      D.25100 = data_align != -4;
      D.25101 = (long int) D.25100;
      D.25102 = __builtin_expect (D.25101, 0);
      if (D.25102 != 0) goto <D.25103>; else goto <D.25104>;
      <D.25103>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "unwind.c", 939, "data_align == DWARF_DATA_ALIGN");
      <D.25104>:
      D.25105 = mono_hw_reg_to_dwarf_reg (14);
      D.25106 = D.25105 != return_reg;
      D.25107 = (long int) D.25106;
      D.25108 = __builtin_expect (D.25107, 0);
      if (D.25108 != 0) goto <D.25109>; else goto <D.25110>;
      <D.25109>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "unwind.c", 940, "return_reg == DWARF_PC_REG");
      <D.25110>:
      cie_len.73 = (sizetype) cie_len;
      D.25112 = cie_len.73 + 4;
      D.25113 = cie + D.25112;
      D.25114 = (int) D.25113;
      cie_cfi.74 = (int) cie_cfi;
      D.25116 = D.25114 - cie_cfi.74;
      fde_len.69 = (sizetype) fde_len;
      D.25073 = fde_len.69 + 4;
      D.25074 = fde + D.25073;
      D.25075 = (int) D.25074;
      fde_cfi.75 = (int) fde_cfi;
      D.25118 = D.25075 - fde_cfi.75;
      buf_len = D.25116 + D.25118;
      buf_len.76 = (unsigned int) buf_len;
      buf = monoeg_malloc0 (buf_len.76);
      i = 0;
      p = cie_cfi;
      goto <D.24678>;
      <D.24677>:
      p.57 = p;
      D.25032 = *p.57;
      if (D.25032 == 0) goto <D.24676>; else goto <D.25120>;
      <D.25120>:
      p.57 = p;
      decode_cie_op (p.57, &p);
      <D.24678>:
      cie_len.73 = (sizetype) cie_len;
      D.25112 = cie_len.73 + 4;
      D.25113 = cie + D.25112;
      p.57 = p;
      if (D.25113 > p.57) goto <D.24677>; else goto <D.24676>;
      <D.24676>:
      i.63 = (sizetype) i;
      D.25121 = buf + i.63;
      p.57 = p;
      p.70 = (int) p.57;
      cie_cfi.74 = (int) cie_cfi;
      D.25122 = p.70 - cie_cfi.74;
      D.25123 = (unsigned int) D.25122;
      memcpy (D.25121, cie_cfi, D.25123);
      p.57 = p;
      p.70 = (int) p.57;
      cie_cfi.74 = (int) cie_cfi;
      D.25122 = p.70 - cie_cfi.74;
      i = D.25122 + i;
      p = fde_cfi;
      goto <D.24681>;
      <D.24680>:
      p.57 = p;
      D.25032 = *p.57;
      if (D.25032 == 0) goto <D.24679>; else goto <D.25124>;
      <D.25124>:
      p.57 = p;
      decode_cie_op (p.57, &p);
      <D.24681>:
      fde_len.69 = (sizetype) fde_len;
      D.25073 = fde_len.69 + 4;
      D.25074 = fde + D.25073;
      p.57 = p;
      if (D.25074 > p.57) goto <D.24680>; else goto <D.24679>;
      <D.24679>:
      i.63 = (sizetype) i;
      D.25121 = buf + i.63;
      p.57 = p;
      p.70 = (int) p.57;
      fde_cfi.75 = (int) fde_cfi;
      D.25125 = p.70 - fde_cfi.75;
      D.25126 = (unsigned int) D.25125;
      memcpy (D.25121, fde_cfi, D.25126);
      p.57 = p;
      p.70 = (int) p.57;
      fde_cfi.75 = (int) fde_cfi;
      D.25125 = p.70 - fde_cfi.75;
      i = D.25125 + i;
      D.25127 = i > buf_len;
      D.25128 = (long int) D.25127;
      D.25129 = __builtin_expect (D.25128, 0);
      if (D.25129 != 0) goto <D.25130>; else goto <D.25131>;
      <D.25130>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "unwind.c", 965, "i <= buf_len");
      <D.25131>:
      i.77 = (unsigned int) i;
      *out_len = i.77;
      i.78 = (unsigned int) i;
      D.25133 = monoeg_realloc (buf, i.78);
      return D.25133;
    }
  finally
    {
      p = {CLOBBER};
    }
}


read_encoded_val (guint32 encoding, guint8 * p, guint8 * * endp)
{
  unsigned int D.25138;
  int D.25139;
  gint64 D.25140;
  gint64 res;

  D.25138 = encoding & 15;
  switch (D.25138) <default: <D.24602>, case 11: <D.24601>, case 12: <D.24599>>
  <D.24599>:
  res = MEM[(gint64 *)p];
  p = p + 8;
  goto <D.24600>;
  <D.24601>:
  D.25139 = MEM[(gint32 *)p];
  res = (gint64) D.25139;
  p = p + 4;
  goto <D.24600>;
  <D.24602>:
  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "unwind.c", 717);
  <D.24600>:
  *endp = p;
  D.25140 = res;
  return D.25140;
}


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.79;
  _Bool D.25143;
  long int D.25144;
  long int D.25145;
  _Bool D.25148;
  long int D.25149;
  long int D.25150;
  unsigned char D.25153;
  guint8 * p.80;
  _Bool D.25157;
  long int D.25158;
  long int D.25159;
  unsigned int D.25162;
  int D.25163;
  _Bool D.25165;
  long int D.25166;
  long int D.25167;
  unsigned int D.25170;
  unsigned int p.81;
  unsigned int D.25172;
  unsigned int D.25173;
  guint8 * p.82;
  unsigned int ncall_sites.83;
  unsigned int D.25178;
  void * D.25179;
  unsigned int ncall_sites.84;
  unsigned int D.25183;
  void * D.25184;
  unsigned int D.25185;
  guint8 * p.85;
  unsigned int D.25187;
  unsigned int D.25188;
  _Bool D.25189;
  long int D.25190;
  long int D.25191;
  unsigned int tinfo.86;
  unsigned int D.25195;
  _Bool D.25196;
  long int D.25197;
  long int D.25198;
  void * * D.25203;
  unsigned int i.87;
  unsigned int D.25207;
  void * * D.25208;
  struct MonoJitExceptionInfo * D.25209;
  unsigned int D.25210;
  struct MonoJitExceptionInfo * D.25211;
  sizetype block_start_offset.88;
  void * D.25213;
  sizetype block_size.89;
  sizetype D.25215;
  guint8 * D.25216;
  sizetype landing_pad.90;
  void * D.25218;
  guint8 * p;
  int i;
  int ncall_sites;
  int this_encoding;
  guint32 mono_magic;
  guint32 version;

  try
    {
      p = lsda;
      p.79 = p;
      mono_magic = decode_uleb128 (p.79, &p);
      D.25143 = mono_magic != 1297084239;
      D.25144 = (long int) D.25143;
      D.25145 = __builtin_expect (D.25144, 0);
      if (D.25145 != 0) goto <D.25146>; else goto <D.25147>;
      <D.25146>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "unwind.c", 740, "mono_magic == 0x4d4fef4f");
      <D.25147>:
      p.79 = p;
      version = decode_uleb128 (p.79, &p);
      D.25148 = version != 1;
      D.25149 = (long int) D.25148;
      D.25150 = __builtin_expect (D.25149, 0);
      if (D.25150 != 0) goto <D.25151>; else goto <D.25152>;
      <D.25151>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "unwind.c", 742, "version == 1");
      <D.25152>:
      p.79 = p;
      D.25153 = *p.79;
      this_encoding = (int) D.25153;
      p.79 = p;
      p.80 = p.79 + 1;
      p = p.80;
      if (this_encoding == 3) goto <D.25155>; else goto <D.25156>;
      <D.25155>:
      {
        gint32 op;
        gint32 reg;
        gint32 offset;

        p.79 = p;
        D.25153 = *p.79;
        op = (gint32) D.25153;
        D.25157 = op != 146;
        D.25158 = (long int) D.25157;
        D.25159 = __builtin_expect (D.25158, 0);
        if (D.25159 != 0) goto <D.25160>; else goto <D.25161>;
        <D.25160>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "unwind.c", 750, "op == DW_OP_bregx");
        <D.25161>:
        p.79 = p;
        p.80 = p.79 + 1;
        p = p.80;
        p.79 = p;
        D.25162 = decode_uleb128 (p.79, &p);
        reg = (gint32) D.25162;
        p.79 = p;
        offset = decode_sleb128 (p.79, &p);
        D.25163 = mono_dwarf_reg_to_hw_reg (reg);
        *this_reg = D.25163;
        *this_offset = offset;
      }
      goto <D.25164>;
      <D.25156>:
      D.25165 = this_encoding != 255;
      D.25166 = (long int) D.25165;
      D.25167 = __builtin_expect (D.25166, 0);
      if (D.25167 != 0) goto <D.25168>; else goto <D.25169>;
      <D.25168>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "unwind.c", 758, "this_encoding == DW_EH_PE_omit");
      <D.25169>:
      *this_reg = -1;
      *this_offset = -1;
      <D.25164>:
      p.79 = p;
      D.25170 = decode_uleb128 (p.79, &p);
      ncall_sites = (int) D.25170;
      p.79 = p;
      p.81 = (unsigned int) p.79;
      D.25172 = p.81 + 3;
      D.25173 = D.25172 & 4294967292;
      p.82 = (guint8 *) D.25173;
      p = p.82;
      if (ex_info != 0B) goto <D.25175>; else goto <D.25176>;
      <D.25175>:
      ncall_sites.83 = (unsigned int) ncall_sites;
      D.25178 = ncall_sites.83 * 24;
      D.25179 = monoeg_malloc0 (D.25178);
      *ex_info = D.25179;
      ncall_sites.84 = (unsigned int) ncall_sites;
      *ex_info_len = ncall_sites.84;
      <D.25176>:
      if (type_info != 0B) goto <D.25181>; else goto <D.25182>;
      <D.25181>:
      ncall_sites.83 = (unsigned int) ncall_sites;
      D.25183 = ncall_sites.83 * 4;
      D.25184 = monoeg_malloc0 (D.25183);
      *type_info = D.25184;
      <D.25182>:
      i = 0;
      goto <D.24626>;
      <D.24625>:
      {
        int block_start_offset;
        int block_size;
        int landing_pad;
        guint8 * tinfo;

        p.79 = p;
        D.25185 = mono_read32 (p.79);
        block_start_offset = (int) D.25185;
        p.79 = p;
        p.85 = p.79 + 4;
        p = p.85;
        p.79 = p;
        D.25187 = mono_read32 (p.79);
        block_size = (int) D.25187;
        p.79 = p;
        p.85 = p.79 + 4;
        p = p.85;
        p.79 = p;
        D.25188 = mono_read32 (p.79);
        landing_pad = (int) D.25188;
        p.79 = p;
        p.85 = p.79 + 4;
        p = p.85;
        tinfo = p;
        p.79 = p;
        p.85 = p.79 + 4;
        p = p.85;
        D.25189 = landing_pad == 0;
        D.25190 = (long int) D.25189;
        D.25191 = __builtin_expect (D.25190, 0);
        if (D.25191 != 0) goto <D.25192>; else goto <D.25193>;
        <D.25192>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "unwind.c", 786, "landing_pad");
        <D.25193>:
        tinfo.86 = (unsigned int) tinfo;
        D.25195 = tinfo.86 & 3;
        D.25196 = D.25195 != 0;
        D.25197 = (long int) D.25196;
        D.25198 = __builtin_expect (D.25197, 0);
        if (D.25198 != 0) goto <D.25199>; else goto <D.25200>;
        <D.25199>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "unwind.c", 787, "((size_t)tinfo % 4) == 0");
        <D.25200>:
        if (ex_info != 0B) goto <D.25201>; else goto <D.25202>;
        <D.25201>:
        D.25203 = *type_info;
        if (D.25203 != 0B) goto <D.25204>; else goto <D.25205>;
        <D.25204>:
        D.25203 = *type_info;
        i.87 = (unsigned int) i;
        D.25207 = i.87 * 4;
        D.25208 = D.25203 + D.25207;
        *D.25208 = tinfo;
        <D.25205>:
        D.25209 = *ex_info;
        i.87 = (unsigned int) i;
        D.25210 = i.87 * 24;
        D.25211 = D.25209 + D.25210;
        block_start_offset.88 = (sizetype) block_start_offset;
        D.25213 = code + block_start_offset.88;
        D.25211->try_start = D.25213;
        D.25209 = *ex_info;
        i.87 = (unsigned int) i;
        D.25210 = i.87 * 24;
        D.25211 = D.25209 + D.25210;
        block_start_offset.88 = (sizetype) block_start_offset;
        block_size.89 = (sizetype) block_size;
        D.25215 = block_start_offset.88 + block_size.89;
        D.25216 = code + D.25215;
        D.25211->try_end = D.25216;
        D.25209 = *ex_info;
        i.87 = (unsigned int) i;
        D.25210 = i.87 * 24;
        D.25211 = D.25209 + D.25210;
        landing_pad.90 = (sizetype) landing_pad;
        D.25218 = code + landing_pad.90;
        D.25211->handler_start = D.25218;
        <D.25202>:
      }
      i = i + 1;
      <D.24626>:
      if (i < ncall_sites) goto <D.24625>; else goto <D.24627>;
      <D.24627>:
    }
  finally
    {
      p = {CLOBBER};
    }
}


decode_cie_op (guint8 * p, guint8 * * endp)
{
  guint8 * p.91;
  unsigned char D.25220;
  int D.25221;
  guint8 * p.92;
  guint8 * p.93;
  int op;

  p.91 = p;
  D.25220 = *p.91;
  D.25221 = (int) D.25220;
  op = D.25221 & 192;
  switch (op) <default: <D.24592>, case 0: <D.24583>, case 64: <D.24580>, case 128: <D.24582>>
  <D.24580>:
  p.91 = p;
  p.92 = p.91 + 1;
  p = p.92;
  goto <D.24581>;
  <D.24582>:
  p.91 = p;
  p.92 = p.91 + 1;
  p = p.92;
  p.91 = p;
  decode_uleb128 (p.91, &p);
  goto <D.24581>;
  <D.24583>:
  {
    int ext_op;

    p.91 = p;
    D.25220 = *p.91;
    ext_op = (int) D.25220;
    p.91 = p;
    p.92 = p.91 + 1;
    p = p.92;
    switch (ext_op) <default: <D.24591>, case 4: <D.24589>, case 12: <D.24585>, case 13: <D.24588>, case 14: <D.24587>, case 17: <D.24590>>
    <D.24585>:
    p.91 = p;
    decode_uleb128 (p.91, &p);
    p.91 = p;
    decode_uleb128 (p.91, &p);
    goto <D.24586>;
    <D.24587>:
    p.91 = p;
    decode_uleb128 (p.91, &p);
    goto <D.24586>;
    <D.24588>:
    p.91 = p;
    decode_uleb128 (p.91, &p);
    goto <D.24586>;
    <D.24589>:
    p.91 = p;
    p.93 = p.91 + 4;
    p = p.93;
    goto <D.24586>;
    <D.24590>:
    p.91 = p;
    decode_uleb128 (p.91, &p);
    p.91 = p;
    decode_uleb128 (p.91, &p);
    goto <D.24586>;
    <D.24591>:
    monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "unwind.c", 691);
    <D.24586>:
    goto <D.24581>;
  }
  <D.24592>:
  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "unwind.c", 696);
  <D.24581>:
  p.91 = p;
  *endp = p.91;
}


mono_unwind_decode_llvm_mono_fde (guint8 * fde, int fde_len, guint8 * cie, guint8 * code, struct MonoLLVMFDEInfo * res)
{
  guint8 * p.94;
  unsigned char D.25225;
  guint8 * p.95;
  unsigned int D.25229;
  guint8 * p.96;
  sizetype aug_len.97;
  guint8 * p.98;
  struct MonoJitExceptionInfo * * D.25236;
  guint32 * D.25237;
  void * * * D.25238;
  int * D.25239;
  int * D.25240;
  unsigned int D.25241;
  unsigned int D.25242;
  unsigned int pers_encoding.99;
  _Bool D.25246;
  long int D.25247;
  long int D.25248;
  _Bool D.25251;
  long int D.25252;
  long int D.25253;
  int D.25256;
  _Bool D.25257;
  long int D.25258;
  long int D.25259;
  int p.100;
  int cie_cfi.101;
  sizetype fde_len.102;
  guint8 * D.25266;
  int D.25267;
  int fde_cfi.103;
  int D.25269;
  unsigned int D.25270;
  unsigned int cie_cfi_len.104;
  sizetype cie_cfi_len.105;
  guint8 * D.25273;
  unsigned int fde_cfi_len.106;
  unsigned int D.25275;
  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, 28);
      res->this_reg = -1;
      res->this_offset = -1;
      p = fde;
      p.94 = p;
      D.25225 = *p.94;
      has_aug = (int) D.25225;
      p.94 = p;
      p.95 = p.94 + 1;
      p = p.95;
      if (has_aug != 0) goto <D.25227>; else goto <D.25228>;
      <D.25227>:
      p.94 = p;
      D.25229 = mono_read32 (p.94);
      aug_len = (int) D.25229;
      p.94 = p;
      p.96 = p.94 + 4;
      p = p.96;
      goto <D.25231>;
      <D.25228>:
      aug_len = 0;
      <D.25231>:
      fde_aug = p;
      p.94 = p;
      aug_len.97 = (sizetype) aug_len;
      p.98 = p.94 + aug_len.97;
      p = p.98;
      fde_cfi = p;
      if (has_aug != 0) goto <D.25234>; else goto <D.25235>;
      <D.25234>:
      {
        guint8 * lsda;

        lsda = fde_aug;
        D.25236 = &res->ex_info;
        D.25237 = &res->ex_info_len;
        D.25238 = &res->type_info;
        D.25239 = &res->this_reg;
        D.25240 = &res->this_offset;
        decode_lsda (lsda, code, D.25236, D.25237, D.25238, D.25239, D.25240);
      }
      <D.25235>:
      p = cie;
      p.94 = p;
      D.25241 = decode_uleb128 (p.94, &p);
      code_align = (gint32) D.25241;
      p.94 = p;
      data_align = decode_sleb128 (p.94, &p);
      p.94 = p;
      D.25242 = decode_uleb128 (p.94, &p);
      return_reg = (gint32) D.25242;
      p.94 = p;
      D.25225 = *p.94;
      pers_encoding = (gint32) D.25225;
      p.94 = p;
      p.95 = p.94 + 1;
      p = p.95;
      if (pers_encoding != 255) goto <D.25243>; else goto <D.25244>;
      <D.25243>:
      pers_encoding.99 = (unsigned int) pers_encoding;
      p.94 = p;
      read_encoded_val (pers_encoding.99, p.94, &p);
      <D.25244>:
      cie_cfi = p;
      D.25246 = code_align != 1;
      D.25247 = (long int) D.25246;
      D.25248 = __builtin_expect (D.25247, 0);
      if (D.25248 != 0) goto <D.25249>; else goto <D.25250>;
      <D.25249>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "unwind.c", 1028, "code_align == 1");
      <D.25250>:
      D.25251 = data_align != -4;
      D.25252 = (long int) D.25251;
      D.25253 = __builtin_expect (D.25252, 0);
      if (D.25253 != 0) goto <D.25254>; else goto <D.25255>;
      <D.25254>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "unwind.c", 1029, "data_align == DWARF_DATA_ALIGN");
      <D.25255>:
      D.25256 = mono_hw_reg_to_dwarf_reg (14);
      D.25257 = D.25256 != return_reg;
      D.25258 = (long int) D.25257;
      D.25259 = __builtin_expect (D.25258, 0);
      if (D.25259 != 0) goto <D.25260>; else goto <D.25261>;
      <D.25260>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "unwind.c", 1030, "return_reg == DWARF_PC_REG");
      <D.25261>:
      p = cie_cfi;
      <D.24704>:
      p.94 = p;
      D.25225 = *p.94;
      if (D.25225 == 0) goto <D.24703>; else goto <D.25262>;
      <D.25262>:
      p.94 = p;
      decode_cie_op (p.94, &p);
      goto <D.24704>;
      <D.24703>:
      p.94 = p;
      p.100 = (int) p.94;
      cie_cfi.101 = (int) cie_cfi;
      cie_cfi_len = p.100 - cie_cfi.101;
      fde_len.102 = (sizetype) fde_len;
      D.25266 = fde + fde_len.102;
      D.25267 = (int) D.25266;
      fde_cfi.103 = (int) fde_cfi;
      fde_cfi_len = D.25267 - fde_cfi.103;
      D.25269 = cie_cfi_len + fde_cfi_len;
      D.25270 = (unsigned int) D.25269;
      buf = monoeg_malloc0 (D.25270);
      cie_cfi_len.104 = (unsigned int) cie_cfi_len;
      memcpy (buf, cie_cfi, cie_cfi_len.104);
      cie_cfi_len.105 = (sizetype) cie_cfi_len;
      D.25273 = buf + cie_cfi_len.105;
      fde_cfi_len.106 = (unsigned int) fde_cfi_len;
      memcpy (D.25273, fde_cfi, fde_cfi_len.106);
      D.25269 = cie_cfi_len + fde_cfi_len;
      D.25275 = (unsigned int) D.25269;
      res->unw_info_len = D.25275;
      res->unw_info = buf;
    }
  finally
    {
      p = {CLOBBER};
    }
}


mono_unwind_get_cie_program ()
{
  struct GSList * D.25276;

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