mono_hw_reg_to_dwarf_reg (int reg)
{
  int D.22721;
  _Bool D.22722;
  long int D.22723;
  long int D.22724;

  if (reg == 256) goto <D.22719>; else goto <D.22720>;
  <D.22719>:
  D.22721 = 108;
  return D.22721;
  <D.22720>:
  D.22722 = reg > 109;
  D.22723 = (long int) D.22722;
  D.22724 = __builtin_expect (D.22723, 0);
  if (D.22724 != 0) goto <D.22725>; else goto <D.22726>;
  <D.22725>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "unwind.c", 122, "reg < NUM_REGS");
  <D.22726>:
  if (0 != 0) goto <D.22727>; else goto <D.22728>;
  <D.22727>:
  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "unwind.c", 126);
  D.22721 = -1;
  return D.22721;
  <D.22728>:
  D.22721 = map_hw_reg_to_dwarf_reg[reg];
  return D.22721;
}


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

  dwarf_reg_to_hw_reg_inited.0 = dwarf_reg_to_hw_reg_inited;
  if (dwarf_reg_to_hw_reg_inited.0 == 0) goto <D.22731>; else goto <D.22732>;
  <D.22731>:
  init_reg_map ();
  <D.22732>:
  D.22733 = map_dwarf_reg_to_hw_reg[reg];
  return D.22733;
}


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

  if (0 != 0) goto <D.22735>; else goto <D.22736>;
  <D.22735>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "unwind.c", 138, "NUM_REGS > 0");
  <D.22736>:
  i = 0;
  goto <D.22393>;
  <D.22392>:
  D.22737 = mono_hw_reg_to_dwarf_reg (i);
  map_dwarf_reg_to_hw_reg[D.22737] = i;
  i = i + 1;
  <D.22393>:
  i.1 = (unsigned int) i;
  if (i.1 <= 31) goto <D.22392>; else goto <D.22394>;
  <D.22394>:
  map_dwarf_reg_to_hw_reg[108] = 256;
  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.22740;
  int D.22741;
  int D.22742;
  guint8 * p.3;
  unsigned int D.22744;
  unsigned int D.22745;
  int D.22748;
  int D.22750;
  const char * D.22751;
  unsigned int D.22752;
  unsigned int D.22753;
  int D.22754;
  const char * D.22755;
  unsigned int D.22756;
  unsigned int D.22757;
  int D.22758;
  const char * D.22759;
  unsigned int D.22760;
  int D.22761;
  int D.22762;
  const char * D.22763;
  unsigned int D.22764;
  unsigned int pos.4;
  unsigned int D.22766;
  guint8 * p.5;
  sizetype D.22768;
  guint8 * D.22769;
  guint8 * p;
  int pos;
  int reg;
  int offset;
  int cfa_reg;
  int cfa_offset;

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

        p.2 = p;
        D.22740 = *p.2;
        D.22741 = (int) D.22740;
        op = D.22741 & 192;
        switch (op) <default: <D.22463>, case 0: <D.22454>, case 64: <D.22451>, case 128: <D.22453>>
        <D.22451>:
        p.2 = p;
        D.22740 = *p.2;
        D.22741 = (int) D.22740;
        D.22742 = D.22741 & 63;
        pos = D.22742 + pos;
        p.2 = p;
        p.3 = p.2 + 1;
        p = p.3;
        goto <D.22452>;
        <D.22453>:
        p.2 = p;
        D.22740 = *p.2;
        D.22741 = (int) D.22740;
        reg = D.22741 & 63;
        p.2 = p;
        p.3 = p.2 + 1;
        p = p.3;
        p.2 = p;
        D.22744 = decode_uleb128 (p.2, &p);
        D.22745 = D.22744 * 4294967288;
        offset = (int) D.22745;
        if (reg == 108) goto <D.22746>; else goto <D.22747>;
        <D.22746>:
        D.22748 = -offset;
        printf ("CFA: [%x] offset: %s at cfa-0x%x\n", pos, "pc", D.22748);
        goto <D.22749>;
        <D.22747>:
        D.22750 = mono_dwarf_reg_to_hw_reg (reg);
        D.22751 = mono_arch_regname (D.22750);
        D.22748 = -offset;
        printf ("CFA: [%x] offset: %s at cfa-0x%x\n", pos, D.22751, D.22748);
        <D.22749>:
        goto <D.22452>;
        <D.22454>:
        {
          int ext_op;

          p.2 = p;
          D.22740 = *p.2;
          ext_op = (int) D.22740;
          p.2 = p;
          p.3 = p.2 + 1;
          p = p.3;
          switch (ext_op) <default: <D.22462>, case 4: <D.22461>, case 12: <D.22456>, case 13: <D.22459>, case 14: <D.22458>, case 17: <D.22460>>
          <D.22456>:
          p.2 = p;
          D.22752 = decode_uleb128 (p.2, &p);
          cfa_reg = (int) D.22752;
          p.2 = p;
          D.22753 = decode_uleb128 (p.2, &p);
          cfa_offset = (int) D.22753;
          D.22754 = mono_dwarf_reg_to_hw_reg (cfa_reg);
          D.22755 = mono_arch_regname (D.22754);
          printf ("CFA: [%x] def_cfa: %s+0x%x\n", pos, D.22755, cfa_offset);
          goto <D.22457>;
          <D.22458>:
          p.2 = p;
          D.22756 = decode_uleb128 (p.2, &p);
          cfa_offset = (int) D.22756;
          printf ("CFA: [%x] def_cfa_offset: 0x%x\n", pos, cfa_offset);
          goto <D.22457>;
          <D.22459>:
          p.2 = p;
          D.22757 = decode_uleb128 (p.2, &p);
          cfa_reg = (int) D.22757;
          D.22758 = mono_dwarf_reg_to_hw_reg (cfa_reg);
          D.22759 = mono_arch_regname (D.22758);
          printf ("CFA: [%x] def_cfa_reg: %s\n", pos, D.22759);
          goto <D.22457>;
          <D.22460>:
          p.2 = p;
          D.22760 = decode_uleb128 (p.2, &p);
          reg = (int) D.22760;
          p.2 = p;
          D.22761 = decode_sleb128 (p.2, &p);
          offset = D.22761 * -8;
          D.22762 = mono_dwarf_reg_to_hw_reg (reg);
          D.22763 = mono_arch_regname (D.22762);
          D.22748 = -offset;
          printf ("CFA: [%x] offset_extended_sf: %s at cfa-0x%x\n", pos, D.22763, D.22748);
          goto <D.22457>;
          <D.22461>:
          p.2 = p;
          D.22764 = MEM[(const guint32 *)p.2];
          pos.4 = (unsigned int) pos;
          D.22766 = D.22764 + pos.4;
          pos = (int) D.22766;
          p.2 = p;
          p.5 = p.2 + 4;
          p = p.5;
          goto <D.22457>;
          <D.22462>:
          monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "unwind.c", 306);
          <D.22457>:
          goto <D.22452>;
        }
        <D.22463>:
        monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "unwind.c", 311);
        <D.22452>:
      }
      <D.22465>:
      D.22768 = (sizetype) unwind_info_len;
      D.22769 = unwind_info + D.22768;
      p.2 = p;
      if (D.22769 > p.2) goto <D.22464>; else goto <D.22466>;
      <D.22466>:
    }
  finally
    {
      p = {CLOBBER};
    }
}


decode_uleb128 (guint8 * buf, guint8 * * endbuf)
{
  int D.22770;
  int D.22771;
  int D.22772;
  unsigned int D.22773;
  signed char b.6;
  guint32 D.22776;
  guint8 * p;
  guint32 res;
  int shift;

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

    b = *p;
    p = p + 1;
    D.22770 = (int) b;
    D.22771 = D.22770 & 127;
    D.22772 = D.22771 << shift;
    D.22773 = (unsigned int) D.22772;
    res = D.22773 | res;
    b.6 = (signed char) b;
    if (b.6 >= 0) goto <D.22428>; else goto <D.22775>;
    <D.22775>:
    shift = shift + 7;
  }
  goto <D.22429>;
  <D.22428>:
  *endbuf = p;
  D.22776 = res;
  return D.22776;
}


decode_sleb128 (guint8 * buf, guint8 * * endbuf)
{
  int D.22778;
  int D.22779;
  int D.22780;
  signed char b.7;
  int D.22786;
  int D.22789;
  int D.22790;
  gint32 D.22791;
  guint8 * p;
  gint32 res;
  int shift;

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

    b = *p;
    p = p + 1;
    D.22778 = (int) b;
    D.22779 = D.22778 & 127;
    D.22780 = D.22779 << shift;
    res = D.22780 | res;
    shift = shift + 7;
    b.7 = (signed char) b;
    if (b.7 >= 0) goto <D.22782>; else goto <D.22783>;
    <D.22782>:
    if (shift <= 31) goto <D.22784>; else goto <D.22785>;
    <D.22784>:
    D.22778 = (int) b;
    D.22786 = D.22778 & 64;
    if (D.22786 != 0) goto <D.22787>; else goto <D.22788>;
    <D.22787>:
    D.22789 = 1 << shift;
    D.22790 = -D.22789;
    res = D.22790 | res;
    <D.22788>:
    <D.22785>:
    goto <D.22438>;
    <D.22783>:
  }
  goto <D.22439>;
  <D.22438>:
  *endbuf = p;
  D.22791 = res;
  return D.22791;
}


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

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


mono_unwind_ops_encode (struct GSList * unwind_ops, guint32 * out_len)
{
  short unsigned int D.22795;
  int D.22796;
  unsigned int D.22797;
  unsigned int loc.8;
  unsigned int D.22799;
  guint8 * p.9;
  guint8 * p.10;
  guint8 * p.11;
  unsigned char D.22805;
  unsigned char D.22806;
  unsigned char D.22807;
  unsigned char D.22808;
  guint8 * p.12;
  guint8 * p.13;
  unsigned char D.22812;
  int D.22813;
  guint8 * p.14;
  guint8 * p.15;
  unsigned int reg.16;
  int D.22817;
  unsigned int D.22818;
  guint8 * p.17;
  guint8 * p.18;
  guint8 * p.19;
  guint8 * p.20;
  guint8 * p.21;
  guint8 * p.22;
  int D.22827;
  guint8 * p.23;
  guint8 * p.24;
  signed char D.22831;
  signed char D.22832;
  unsigned char D.22833;
  unsigned int D.22834;
  long int p.25;
  long int buf.26;
  long int D.22837;
  _Bool D.22838;
  long int D.22839;
  long int D.22840;
  unsigned int D.22843;
  long unsigned int D.22844;
  long unsigned int D.22845;
  guint8 * D.22846;
  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.22488>;
      <D.22487>:
      {
        int reg;

        op = l->data;
        D.22795 = op->reg;
        D.22796 = (int) D.22795;
        reg = mono_hw_reg_to_dwarf_reg (D.22796);
        goto <D.22479>;
        <D.22478>:
        D.22797 = op->when;
        loc.8 = (unsigned int) loc;
        D.22799 = D.22797 - loc.8;
        if (D.22799 <= 31) goto <D.22800>; else goto <D.22801>;
        <D.22800>:
        p.9 = p;
        p.10 = p.9;
        p.11 = p.10 + 1;
        p = p.11;
        D.22797 = op->when;
        D.22805 = (unsigned char) D.22797;
        D.22806 = (unsigned char) loc;
        D.22807 = D.22805 - D.22806;
        D.22808 = D.22807 | 64;
        *p.10 = D.22808;
        D.22797 = op->when;
        loc = (int) D.22797;
        goto <D.22809>;
        <D.22801>:
        p.9 = p;
        p.12 = p.9;
        p.13 = p.12 + 1;
        p = p.13;
        *p.12 = 94;
        loc = loc + 30;
        <D.22809>:
        <D.22479>:
        D.22797 = op->when;
        loc.8 = (unsigned int) loc;
        if (D.22797 > loc.8) goto <D.22478>; else goto <D.22480>;
        <D.22480>:
        D.22812 = op->op;
        D.22813 = (int) D.22812;
        switch (D.22813) <default: <D.22486>, case 12: <D.22481>, case 13: <D.22484>, case 14: <D.22483>, case 128: <D.22485>>
        <D.22481>:
        p.9 = p;
        p.14 = p.9;
        p.15 = p.14 + 1;
        p = p.15;
        D.22812 = op->op;
        *p.14 = D.22812;
        reg.16 = (unsigned int) reg;
        p.9 = p;
        encode_uleb128 (reg.16, p.9, &p);
        D.22817 = op->val;
        D.22818 = (unsigned int) D.22817;
        p.9 = p;
        encode_uleb128 (D.22818, p.9, &p);
        goto <D.22482>;
        <D.22483>:
        p.9 = p;
        p.17 = p.9;
        p.18 = p.17 + 1;
        p = p.18;
        D.22812 = op->op;
        *p.17 = D.22812;
        D.22817 = op->val;
        D.22818 = (unsigned int) D.22817;
        p.9 = p;
        encode_uleb128 (D.22818, p.9, &p);
        goto <D.22482>;
        <D.22484>:
        p.9 = p;
        p.19 = p.9;
        p.20 = p.19 + 1;
        p = p.20;
        D.22812 = op->op;
        *p.19 = D.22812;
        reg.16 = (unsigned int) reg;
        p.9 = p;
        encode_uleb128 (reg.16, p.9, &p);
        goto <D.22482>;
        <D.22485>:
        if (reg > 63) goto <D.22823>; else goto <D.22824>;
        <D.22823>:
        p.9 = p;
        p.21 = p.9;
        p.22 = p.21 + 1;
        p = p.22;
        *p.21 = 17;
        reg.16 = (unsigned int) reg;
        p.9 = p;
        encode_uleb128 (reg.16, p.9, &p);
        D.22817 = op->val;
        D.22827 = D.22817 / -8;
        p.9 = p;
        encode_sleb128 (D.22827, p.9, &p);
        goto <D.22828>;
        <D.22824>:
        p.9 = p;
        p.23 = p.9;
        p.24 = p.23 + 1;
        p = p.24;
        D.22831 = (signed char) reg;
        D.22832 = D.22831 | -128;
        D.22833 = (unsigned char) D.22832;
        *p.23 = D.22833;
        D.22817 = op->val;
        D.22827 = D.22817 / -8;
        D.22834 = (unsigned int) D.22827;
        p.9 = p;
        encode_uleb128 (D.22834, p.9, &p);
        <D.22828>:
        goto <D.22482>;
        <D.22486>:
        monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "unwind.c", 378);
        <D.22482>:
      }
      l = l->next;
      <D.22488>:
      if (l != 0B) goto <D.22487>; else goto <D.22489>;
      <D.22489>:
      p.9 = p;
      p.25 = (long int) p.9;
      buf.26 = (long int) buf;
      D.22837 = p.25 - buf.26;
      D.22838 = D.22837 > 4095;
      D.22839 = (long int) D.22838;
      D.22840 = __builtin_expect (D.22839, 0);
      if (D.22840 != 0) goto <D.22841>; else goto <D.22842>;
      <D.22841>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "unwind.c", 383, "p - buf < 4096");
      <D.22842>:
      p.9 = p;
      p.25 = (long int) p.9;
      buf.26 = (long int) buf;
      D.22837 = p.25 - buf.26;
      D.22843 = (unsigned int) D.22837;
      *out_len = D.22843;
      p.9 = p;
      p.25 = (long int) p.9;
      buf.26 = (long int) buf;
      D.22837 = p.25 - buf.26;
      D.22844 = (long unsigned int) D.22837;
      res = monoeg_malloc (D.22844);
      p.9 = p;
      p.25 = (long int) p.9;
      buf.26 = (long int) buf;
      D.22837 = p.25 - buf.26;
      D.22845 = (long unsigned int) D.22837;
      memcpy (res, buf, D.22845);
      monoeg_g_free (buf);
      D.22846 = res;
      return D.22846;
    }
  finally
    {
      p = {CLOBBER};
    }
}


encode_sleb128 (gint32 value, guint8 * buf, guint8 * * endbuf)
{
  _Bool D.22849;
  unsigned char D.22850;
  unsigned int D.22853;
  int D.22854;
  int D.22855;
  int D.22856;
  int D.22862;
  int D.22863;
  guint8 * p.27;
  gboolean more;
  gboolean negative;
  guint32 size;
  guint8 byte;
  guint8 * p;

  more = 1;
  D.22849 = value < 0;
  negative = (gboolean) D.22849;
  size = 32;
  p = buf;
  goto <D.22418>;
  <D.22417>:
  D.22850 = (unsigned char) value;
  byte = D.22850 & 127;
  value = value >> 7;
  if (negative != 0) goto <D.22851>; else goto <D.22852>;
  <D.22851>:
  D.22853 = size + 4294967289;
  D.22854 = (int) D.22853;
  D.22855 = 1 << D.22854;
  D.22856 = -D.22855;
  value = D.22856 | value;
  <D.22852>:
  if (value == 0) goto <D.22861>; else goto <D.22857>;
  <D.22861>:
  D.22862 = (int) byte;
  D.22863 = D.22862 & 64;
  if (D.22863 == 0) goto <D.22858>; else goto <D.22857>;
  <D.22857>:
  if (value == -1) goto <D.22864>; else goto <D.22859>;
  <D.22864>:
  D.22862 = (int) byte;
  D.22863 = D.22862 & 64;
  if (D.22863 != 0) goto <D.22858>; else goto <D.22859>;
  <D.22858>:
  more = 0;
  goto <D.22860>;
  <D.22859>:
  byte = byte | 128;
  <D.22860>:
  p.27 = p;
  p = p.27 + 1;
  *p.27 = byte;
  <D.22418>:
  if (more != 0) goto <D.22417>; else goto <D.22419>;
  <D.22419>:
  *endbuf = p;
}


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

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

    D.22866 = (unsigned char) value;
    b = D.22866 & 127;
    value = value >> 7;
    if (value != 0) goto <D.22867>; else goto <D.22868>;
    <D.22867>:
    b = b | 128;
    <D.22868>:
    p.28 = p;
    p = p.28 + 1;
    *p.28 = b;
  }
  if (value != 0) goto <D.22405>; else goto <D.22406>;
  <D.22406>:
  *endbuf = p;
}


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

  D.22871 = __builtin_object_size (__dest, 0);
  D.22870 = __builtin___memcpy_chk (__dest, __src, __len, D.22871);
  return D.22870;
}


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.22874;
  int D.22875;
  int D.22876;
  guint8 * p.30;
  unsigned int D.22878;
  unsigned int D.22879;
  int D.22880;
  unsigned int D.22881;
  unsigned int D.22882;
  unsigned int D.22883;
  unsigned int D.22884;
  unsigned int D.22885;
  _Bool D.22886;
  long int D.22887;
  long int D.22888;
  int D.22891;
  unsigned int D.22892;
  unsigned int D.22893;
  unsigned int D.22896;
  unsigned int pos.31;
  unsigned int D.22898;
  guint8 * p.32;
  long int D.22900;
  long int ip.33;
  long int start_ip.34;
  long int D.22903;
  sizetype D.22905;
  guint8 * D.22906;
  long unsigned int D.22909;
  long unsigned int D.22910;
  sizetype D.22911;
  int D.22912;
  long unsigned int D.22913;
  long unsigned int D.22914;
  mgreg_t * D.22915;
  long int D.22916;
  sizetype D.22917;
  sizetype D.22918;
  unsigned char D.22919;
  <unnamed type> D.22922;
  _Bool D.22925;
  long int D.22926;
  long int D.22927;
  long unsigned int D.22930;
  long unsigned int D.22931;
  mgreg_t * D.22932;
  int D.22933;
  sizetype D.22934;
  mgreg_t * D.22935;
  long int D.22936;
  mgreg_t * * D.22941;
  struct Loc locations[110];
  guint8 reg_saved[110];
  int i;
  int pos;
  int reg;
  int cfa_reg;
  int cfa_offset;
  int offset;
  guint8 * p;
  guint8 * cfa_val;

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

        p.29 = p;
        D.22874 = *p.29;
        D.22875 = (int) D.22874;
        op = D.22875 & 192;
        switch (op) <default: <D.22538>, case 0: <D.22528>, case 64: <D.22525>, case 128: <D.22527>>
        <D.22525>:
        p.29 = p;
        D.22874 = *p.29;
        D.22875 = (int) D.22874;
        D.22876 = D.22875 & 63;
        pos = D.22876 + pos;
        p.29 = p;
        p.30 = p.29 + 1;
        p = p.30;
        goto <D.22526>;
        <D.22527>:
        p.29 = p;
        D.22874 = *p.29;
        D.22875 = (int) D.22874;
        reg = D.22875 & 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.22878 = decode_uleb128 (p.29, &p);
        D.22879 = D.22878 * 4294967288;
        D.22880 = (int) D.22879;
        locations[reg].offset = D.22880;
        goto <D.22526>;
        <D.22528>:
        {
          int ext_op;

          p.29 = p;
          D.22874 = *p.29;
          ext_op = (int) D.22874;
          p.29 = p;
          p.30 = p.29 + 1;
          p = p.30;
          switch (ext_op) <default: <D.22537>, case 4: <D.22536>, case 5: <D.22535>, case 12: <D.22530>, case 13: <D.22533>, case 14: <D.22532>, case 17: <D.22534>>
          <D.22530>:
          p.29 = p;
          D.22881 = decode_uleb128 (p.29, &p);
          cfa_reg = (int) D.22881;
          p.29 = p;
          D.22882 = decode_uleb128 (p.29, &p);
          cfa_offset = (int) D.22882;
          goto <D.22531>;
          <D.22532>:
          p.29 = p;
          D.22883 = decode_uleb128 (p.29, &p);
          cfa_offset = (int) D.22883;
          goto <D.22531>;
          <D.22533>:
          p.29 = p;
          D.22884 = decode_uleb128 (p.29, &p);
          cfa_reg = (int) D.22884;
          goto <D.22531>;
          <D.22534>:
          p.29 = p;
          D.22885 = decode_uleb128 (p.29, &p);
          reg = (int) D.22885;
          p.29 = p;
          offset = decode_sleb128 (p.29, &p);
          D.22886 = reg > 109;
          D.22887 = (long int) D.22886;
          D.22888 = __builtin_expect (D.22887, 0);
          if (D.22888 != 0) goto <D.22889>; else goto <D.22890>;
          <D.22889>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "unwind.c", 470, "reg < NUM_REGS");
          <D.22890>:
          reg_saved[reg] = 1;
          locations[reg].loc_type = 1;
          D.22891 = offset * -8;
          locations[reg].offset = D.22891;
          goto <D.22531>;
          <D.22535>:
          p.29 = p;
          D.22892 = decode_uleb128 (p.29, &p);
          reg = (int) D.22892;
          p.29 = p;
          D.22893 = decode_uleb128 (p.29, &p);
          offset = (int) D.22893;
          D.22886 = reg > 109;
          D.22887 = (long int) D.22886;
          D.22888 = __builtin_expect (D.22887, 0);
          if (D.22888 != 0) goto <D.22894>; else goto <D.22895>;
          <D.22894>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "unwind.c", 478, "reg < NUM_REGS");
          <D.22895>:
          reg_saved[reg] = 1;
          locations[reg].loc_type = 1;
          D.22891 = offset * -8;
          locations[reg].offset = D.22891;
          goto <D.22531>;
          <D.22536>:
          p.29 = p;
          D.22896 = MEM[(const guint32 *)p.29];
          pos.31 = (unsigned int) pos;
          D.22898 = D.22896 + pos.31;
          pos = (int) D.22898;
          p.29 = p;
          p.32 = p.29 + 4;
          p = p.32;
          goto <D.22531>;
          <D.22537>:
          monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "unwind.c", 488);
          <D.22531>:
          goto <D.22526>;
        }
        <D.22538>:
        monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "unwind.c", 493);
        <D.22526>:
      }
      <D.22540>:
      D.22900 = (long int) pos;
      ip.33 = (long int) ip;
      start_ip.34 = (long int) start_ip;
      D.22903 = ip.33 - start_ip.34;
      if (D.22900 <= D.22903) goto <D.22904>; else goto <D.22541>;
      <D.22904>:
      D.22905 = (sizetype) unwind_info_len;
      D.22906 = unwind_info + D.22905;
      p.29 = p;
      if (D.22906 > p.29) goto <D.22539>; else goto <D.22541>;
      <D.22541>:
      if (save_locations != 0B) goto <D.22907>; else goto <D.22908>;
      <D.22907>:
      D.22909 = (long unsigned int) save_locations_len;
      D.22910 = D.22909 * 8;
      memset (save_locations, 0, D.22910);
      <D.22908>:
      D.22911 = (sizetype) cfa_offset;
      D.22912 = mono_dwarf_reg_to_hw_reg (cfa_reg);
      D.22913 = (long unsigned int) D.22912;
      D.22914 = D.22913 * 8;
      D.22915 = regs + D.22914;
      D.22916 = *D.22915;
      D.22917 = (sizetype) D.22916;
      D.22918 = D.22911 + D.22917;
      cfa_val = (guint8 *) D.22918;
      i = 0;
      goto <D.22544>;
      <D.22543>:
      D.22919 = reg_saved[i];
      if (D.22919 != 0) goto <D.22920>; else goto <D.22921>;
      <D.22920>:
      D.22922 = locations[i].loc_type;
      if (D.22922 == 1) goto <D.22923>; else goto <D.22924>;
      <D.22923>:
      {
        int hreg;

        hreg = mono_dwarf_reg_to_hw_reg (i);
        D.22925 = hreg >= nregs;
        D.22926 = (long int) D.22925;
        D.22927 = __builtin_expect (D.22926, 0);
        if (D.22927 != 0) goto <D.22928>; else goto <D.22929>;
        <D.22928>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "unwind.c", 504, "hreg < nregs");
        <D.22929>:
        D.22930 = (long unsigned int) hreg;
        D.22931 = D.22930 * 8;
        D.22932 = regs + D.22931;
        D.22933 = locations[i].offset;
        D.22934 = (sizetype) D.22933;
        D.22935 = cfa_val + D.22934;
        D.22936 = *D.22935;
        *D.22932 = D.22936;
        if (save_locations != 0B) goto <D.22937>; else goto <D.22938>;
        <D.22937>:
        if (hreg < save_locations_len) goto <D.22939>; else goto <D.22940>;
        <D.22939>:
        D.22930 = (long unsigned int) hreg;
        D.22931 = D.22930 * 8;
        D.22941 = save_locations + D.22931;
        D.22933 = locations[i].offset;
        D.22934 = (sizetype) D.22933;
        D.22935 = cfa_val + D.22934;
        *D.22941 = D.22935;
        <D.22940>:
        <D.22938>:
      }
      <D.22924>:
      <D.22921>:
      i = i + 1;
      <D.22544>:
      if (i <= 109) goto <D.22543>; else goto <D.22545>;
      <D.22545>:
      *out_cfa = cfa_val;
    }
  finally
    {
      locations = {CLOBBER};
      reg_saved = {CLOBBER};
      p = {CLOBBER};
    }
}


memset (void * __dest, int __ch, size_t __len)
{
  int D.22944;
  int D.22949;
  void * D.22951;
  long unsigned int D.22952;

  D.22944 = __builtin_constant_p (__len);
  if (D.22944 != 0) goto <D.22945>; else goto <D.22946>;
  <D.22945>:
  if (__len == 0) goto <D.22947>; else goto <D.22948>;
  <D.22947>:
  D.22949 = __builtin_constant_p (__ch);
  if (D.22949 == 0) goto <D.22942>; else goto <D.22950>;
  <D.22950>:
  if (__ch != 0) goto <D.22942>; else goto <D.22943>;
  <D.22942>:
  __warn_memset_zero_len ();
  D.22951 = __dest;
  return D.22951;
  <D.22943>:
  <D.22948>:
  <D.22946>:
  D.22952 = __builtin_object_size (__dest, 0);
  D.22951 = __builtin___memset_chk (__dest, __ch, __len, D.22952);
  return D.22951;
}


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.22957;
  long unsigned int D.22958;
  struct MonoUnwindInfo * * D.22959;
  int cached_info_next.36;
  int i;

  DeleteCriticalSection (&unwind_mutex);
  cached_info.35 = cached_info;
  if (cached_info.35 == 0B) goto <D.22955>; else goto <D.22956>;
  <D.22955>:
  return;
  <D.22956>:
  i = 0;
  goto <D.22555>;
  <D.22554>:
  {
    struct MonoUnwindInfo * cached;

    cached_info.35 = cached_info;
    D.22957 = (long unsigned int) i;
    D.22958 = D.22957 * 8;
    D.22959 = cached_info.35 + D.22958;
    cached = *D.22959;
    monoeg_g_free (cached);
  }
  i = i + 1;
  <D.22555>:
  cached_info_next.36 = cached_info_next;
  if (i < cached_info_next.36) goto <D.22554>; else goto <D.22556>;
  <D.22556>:
  cached_info.35 = cached_info;
  monoeg_g_free (cached_info.35);
}


mono_cache_unwind_info (guint8 * unwind_info, guint32 unwind_info_len)
{
  _Bool D.22964;
  long int D.22965;
  long int D.22966;
  struct MonoUnwindInfo * * cached_info.37;
  int cached_info_size.38;
  long unsigned int D.22973;
  long unsigned int D.22974;
  void * cached_info.39;
  long unsigned int D.22976;
  long unsigned int D.22977;
  struct MonoUnwindInfo * * D.22978;
  unsigned int D.22979;
  guint8[0:] * D.22982;
  long unsigned int D.22983;
  int D.22984;
  _Bool D.22989;
  long int D.22990;
  long int D.22991;
  guint32 D.22994;
  int cached_info_next.40;
  long unsigned int D.22996;
  long unsigned int D.22997;
  guint8[0:] * D.22998;
  int cached_info_size.43;
  long unsigned int D.23002;
  long unsigned int D.23003;
  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.23008;
  long unsigned int D.23009;
  struct MonoUnwindInfo * * D.23010;
  int unwind_info_size.46;
  unsigned int unwind_info_size.47;
  unsigned int D.23013;
  unsigned int D.23014;
  int unwind_info_size.48;
  _Bool D.23018;
  long int D.23019;
  long int D.23020;
  int i;
  struct MonoUnwindInfo * info;

  {
    int ret;

    ret = pthread_mutex_lock (&unwind_mutex.mutex);
    if (ret != 0) goto <D.22962>; else goto <D.22963>;
    <D.22962>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
    <D.22963>:
    D.22964 = ret != 0;
    D.22965 = (long int) D.22964;
    D.22966 = __builtin_expect (D.22965, 0);
    if (D.22966 != 0) goto <D.22967>; else goto <D.22968>;
    <D.22967>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "unwind.c", 557, "ret == 0");
    <D.22968>:
  }
  cached_info.37 = cached_info;
  if (cached_info.37 == 0B) goto <D.22970>; else goto <D.22971>;
  <D.22970>:
  cached_info_size = 16;
  cached_info_size.38 = cached_info_size;
  D.22973 = (long unsigned int) cached_info_size.38;
  D.22974 = D.22973 * 8;
  cached_info.39 = monoeg_malloc0 (D.22974);
  cached_info = cached_info.39;
  <D.22971>:
  i = 0;
  goto <D.22567>;
  <D.22566>:
  {
    struct MonoUnwindInfo * cached;

    cached_info.37 = cached_info;
    D.22976 = (long unsigned int) i;
    D.22977 = D.22976 * 8;
    D.22978 = cached_info.37 + D.22977;
    cached = *D.22978;
    D.22979 = cached->len;
    if (D.22979 == unwind_info_len) goto <D.22980>; else goto <D.22981>;
    <D.22980>:
    D.22982 = &cached->info;
    D.22983 = (long unsigned int) unwind_info_len;
    D.22984 = memcmp (D.22982, unwind_info, D.22983);
    if (D.22984 == 0) goto <D.22985>; else goto <D.22986>;
    <D.22985>:
    {
      int ret;

      ret = pthread_mutex_unlock (&unwind_mutex.mutex);
      if (ret != 0) goto <D.22987>; else goto <D.22988>;
      <D.22987>:
      monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
      <D.22988>:
      D.22989 = ret != 0;
      D.22990 = (long int) D.22989;
      D.22991 = __builtin_expect (D.22990, 0);
      if (D.22991 != 0) goto <D.22992>; else goto <D.22993>;
      <D.22992>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "unwind.c", 568, "ret == 0");
      <D.22993>:
    }
    D.22994 = (guint32) i;
    return D.22994;
    <D.22986>:
    <D.22981>:
  }
  i = i + 1;
  <D.22567>:
  cached_info_next.40 = cached_info_next;
  if (i < cached_info_next.40) goto <D.22566>; else goto <D.22568>;
  <D.22568>:
  D.22996 = (long unsigned int) unwind_info_len;
  D.22997 = D.22996 + 4;
  info = monoeg_malloc (D.22997);
  info->len = unwind_info_len;
  D.22998 = &info->info;
  D.22983 = (long unsigned int) unwind_info_len;
  memcpy (D.22998, unwind_info, D.22983);
  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.22999>; else goto <D.23000>;
  <D.22999>:
  {
    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.23002 = (long unsigned int) cached_info_size.43;
    D.23003 = D.23002 * 8;
    new_table = monoeg_malloc0 (D.23003);
    cached_info.37 = cached_info;
    cached_info_size.38 = cached_info_size;
    D.22973 = (long unsigned int) cached_info_size.38;
    D.22974 = D.22973 * 8;
    memcpy (new_table, cached_info.37, D.22974);
    mono_memory_barrier ();
    cached_info = new_table;
    cached_info_list.41 = cached_info_list;
    cached_info.37 = cached_info;
    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.23000>:
  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.23008 = (long unsigned int) cached_info_next.44;
  D.23009 = D.23008 * 8;
  D.23010 = cached_info.37 + D.23009;
  *D.23010 = info;
  unwind_info_size.46 = unwind_info_size;
  unwind_info_size.47 = (unsigned int) unwind_info_size.46;
  D.23013 = unwind_info_size.47 + unwind_info_len;
  D.23014 = D.23013 + 4;
  unwind_info_size.48 = (int) D.23014;
  unwind_info_size = unwind_info_size.48;
  {
    int ret;

    ret = pthread_mutex_unlock (&unwind_mutex.mutex);
    if (ret != 0) goto <D.23016>; else goto <D.23017>;
    <D.23016>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.23017>:
    D.23018 = ret != 0;
    D.23019 = (long int) D.23018;
    D.23020 = __builtin_expect (D.23019, 0);
    if (D.23020 != 0) goto <D.23021>; else goto <D.23022>;
    <D.23021>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "unwind.c", 605, "ret == 0");
    <D.23022>:
  }
  D.22994 = (guint32) i;
  return D.22994;
}


mono_get_cached_unwind_info (guint32 index, guint32 * unwind_info_len)
{
  long unsigned int D.23024;
  long unsigned int D.23025;
  struct MonoUnwindInfo * * D.23026;
  unsigned int D.23027;
  guint8 * D.23028;
  struct MonoUnwindInfo * * table;
  struct MonoUnwindInfo * info;
  guint8 * data;

  table = cached_info;
  D.23024 = (long unsigned int) index;
  D.23025 = D.23024 * 8;
  D.23026 = table + D.23025;
  info = *D.23026;
  D.23027 = info->len;
  *unwind_info_len = D.23027;
  data = &info->info;
  D.23028 = data;
  return D.23028;
}


mono_unwind_get_dwarf_data_align ()
{
  int D.23030;

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


mono_unwind_get_dwarf_pc_reg ()
{
  int D.23032;

  D.23032 = 108;
  return D.23032;
}


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.23035;
  unsigned int fde_len.50;
  unsigned int D.23037;
  _Bool D.23038;
  long int D.23039;
  long int D.23040;
  guint8 * p.51;
  sizetype D.23044;
  sizetype D.23045;
  _Bool D.23046;
  long int D.23047;
  long int D.23048;
  unsigned char D.23051;
  _Bool D.23052;
  long int D.23053;
  long int D.23054;
  guint8 * p.52;
  long unsigned int D.23058;
  sizetype D.23059;
  guint8 * p.53;
  unsigned int D.23061;
  unsigned int D.23062;
  char * D.23063;
  unsigned int D.23066;
  sizetype D.23067;
  char * D.23068;
  char D.23069;
  int D.23070;
  unsigned char D.23071;
  _Bool D.23072;
  long int D.23073;
  long int D.23074;
  _Bool D.23077;
  long int D.23078;
  long int D.23079;
  sizetype D.23082;
  guint8 * p.54;
  sizetype D.23084;
  unsigned int D.23087;
  sizetype D.23088;
  guint8 * p.55;
  sizetype D.23091;
  sizetype D.23092;
  guint8 * D.23093;
  long int D.23094;
  long int p.56;
  long int D.23096;
  unsigned int pc_range.57;
  unsigned int D.23106;
  long int D.23110;
  sizetype D.23114;
  _Bool D.23115;
  long int D.23116;
  long int D.23117;
  _Bool D.23120;
  long int D.23121;
  long int D.23122;
  _Bool D.23125;
  long int D.23126;
  long int D.23127;
  sizetype D.23130;
  sizetype D.23131;
  guint8 * D.23132;
  long int D.23133;
  long int cie_cfi.58;
  long int D.23135;
  unsigned int D.23136;
  long int fde_cfi.59;
  long int D.23138;
  unsigned int D.23139;
  unsigned int D.23140;
  long unsigned int D.23141;
  guint8 * D.23143;
  long int D.23144;
  long unsigned int D.23145;
  unsigned int D.23146;
  unsigned int i.60;
  unsigned int D.23148;
  long int D.23150;
  long unsigned int D.23151;
  unsigned int D.23152;
  unsigned int D.23153;
  _Bool D.23154;
  long int D.23155;
  long int D.23156;
  unsigned int i.61;
  guint8 * D.23160;
  long unsigned int D.23161;
  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.23035 = MEM[(guint32 *)p.49];
      fde_len = (gint32) D.23035;
      fde_len.50 = (unsigned int) fde_len;
      D.23037 = fde_len.50 + 1;
      D.23038 = D.23037 <= 1;
      D.23039 = (long int) D.23038;
      D.23040 = __builtin_expect (D.23039, 0);
      if (D.23040 != 0) goto <D.23041>; else goto <D.23042>;
      <D.23041>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "unwind.c", 833, "fde_len != 0xffffffff && fde_len != 0");
      <D.23042>:
      p.49 = p;
      p.51 = p.49 + 4;
      p = p.51;
      p.49 = p;
      D.23035 = MEM[(guint32 *)p.49];
      cie_offset = (gint32) D.23035;
      p.49 = p;
      D.23044 = (sizetype) cie_offset;
      D.23045 = -D.23044;
      cie = p.49 + D.23045;
      p.49 = p;
      p.51 = p.49 + 4;
      p = p.51;
      fde_current = p;
      p = cie;
      p.49 = p;
      D.23035 = MEM[(guint32 *)p.49];
      cie_len = (gint32) D.23035;
      p.49 = p;
      p.51 = p.49 + 4;
      p = p.51;
      p.49 = p;
      D.23035 = MEM[(guint32 *)p.49];
      cie_id = (gint32) D.23035;
      D.23046 = cie_id != 0;
      D.23047 = (long int) D.23046;
      D.23048 = __builtin_expect (D.23047, 0);
      if (D.23048 != 0) goto <D.23049>; else goto <D.23050>;
      <D.23049>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "unwind.c", 845, "cie_id == 0");
      <D.23050>:
      p.49 = p;
      p.51 = p.49 + 4;
      p = p.51;
      p.49 = p;
      D.23051 = *p.49;
      cie_version = (gint32) D.23051;
      D.23052 = cie_version != 1;
      D.23053 = (long int) D.23052;
      D.23054 = __builtin_expect (D.23053, 0);
      if (D.23054 != 0) goto <D.23055>; else goto <D.23056>;
      <D.23055>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "unwind.c", 848, "cie_version == 1");
      <D.23056>:
      p.49 = p;
      p.52 = p.49 + 1;
      p = p.52;
      cie_aug_str = p;
      p.49 = p;
      D.23058 = strlen (cie_aug_str);
      D.23059 = D.23058 + 1;
      p.53 = p.49 + D.23059;
      p = p.53;
      p.49 = p;
      D.23061 = decode_uleb128 (p.49, &p);
      code_align = (gint32) D.23061;
      p.49 = p;
      data_align = decode_sleb128 (p.49, &p);
      p.49 = p;
      D.23062 = decode_uleb128 (p.49, &p);
      return_reg = (gint32) D.23062;
      D.23063 = __builtin_strchr (cie_aug_str, 122);
      if (D.23063 != 0B) goto <D.23064>; else goto <D.23065>;
      <D.23064>:
      {
        guint8 * cie_aug;
        guint32 p_encoding;

        p.49 = p;
        D.23066 = decode_uleb128 (p.49, &p);
        cie_aug_len = (gint32) D.23066;
        has_fde_augmentation = 1;
        cie_aug = p;
        i = 0;
        goto <D.22682>;
        <D.22681>:
        D.23067 = (sizetype) i;
        D.23068 = cie_aug_str + D.23067;
        D.23069 = *D.23068;
        D.23070 = (int) D.23069;
        switch (D.23070) <default: <D.22680>, case 76: <D.22678>, case 80: <D.22677>, case 82: <D.22679>, case 122: <D.22675>>
        <D.22675>:
        goto <D.22676>;
        <D.22677>:
        p.49 = p;
        D.23051 = *p.49;
        p_encoding = (guint32) D.23051;
        p.49 = p;
        p.52 = p.49 + 1;
        p = p.52;
        p.49 = p;
        read_encoded_val (p_encoding, p.49, &p);
        goto <D.22676>;
        <D.22678>:
        p.49 = p;
        D.23051 = *p.49;
        D.23071 = D.23051 + 229;
        D.23072 = D.23071 > 1;
        D.23073 = (long int) D.23072;
        D.23074 = __builtin_expect (D.23073, 0);
        if (D.23074 != 0) goto <D.23075>; else goto <D.23076>;
        <D.23075>:
        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.23076>:
        p.49 = p;
        p.52 = p.49 + 1;
        p = p.52;
        goto <D.22676>;
        <D.22679>:
        p.49 = p;
        D.23051 = *p.49;
        D.23077 = D.23051 != 27;
        D.23078 = (long int) D.23077;
        D.23079 = __builtin_expect (D.23078, 0);
        if (D.23079 != 0) goto <D.23080>; else goto <D.23081>;
        <D.23080>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "unwind.c", 878, "*p == (DW_EH_PE_sdata4|DW_EH_PE_pcrel)");
        <D.23081>:
        p.49 = p;
        p.52 = p.49 + 1;
        p = p.52;
        goto <D.22676>;
        <D.22680>:
        monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "unwind.c", 882);
        <D.22676>:
        i = i + 1;
        <D.22682>:
        D.23067 = (sizetype) i;
        D.23068 = cie_aug_str + D.23067;
        D.23069 = *D.23068;
        if (D.23069 != 0) goto <D.22681>; else goto <D.22683>;
        <D.22683>:
        p = cie_aug;
        p.49 = p;
        D.23082 = (sizetype) cie_aug_len;
        p.54 = p.49 + D.23082;
        p = p.54;
      }
      <D.23065>:
      cie_cfi = p;
      p = fde_current;
      p.49 = p;
      pc_begin = MEM[(gint32 *)p.49];
      p.49 = p;
      D.23084 = (sizetype) pc_begin;
      code = p.49 + D.23084;
      p.49 = p;
      p.51 = p.49 + 4;
      p = p.51;
      p.49 = p;
      D.23035 = MEM[(guint32 *)p.49];
      pc_range = (gint32) D.23035;
      p.49 = p;
      p.51 = p.49 + 4;
      p = p.51;
      if (has_fde_augmentation != 0) goto <D.23085>; else goto <D.23086>;
      <D.23085>:
      p.49 = p;
      D.23087 = decode_uleb128 (p.49, &p);
      aug_len = (gint32) D.23087;
      fde_aug = p;
      p.49 = p;
      D.23088 = (sizetype) aug_len;
      p.55 = p.49 + D.23088;
      p = p.55;
      goto <D.23090>;
      <D.23086>:
      aug_len = 0;
      <D.23090>:
      fde_cfi = p;
      D.23091 = (sizetype) fde_len;
      D.23092 = D.23091 + 4;
      D.23093 = fde + D.23092;
      D.23094 = (long int) D.23093;
      p.49 = p;
      p.56 = (long int) p.49;
      D.23096 = D.23094 - p.56;
      fde_data_len = (gint32) D.23096;
      if (code_len != 0B) goto <D.23097>; else goto <D.23098>;
      <D.23097>:
      pc_range.57 = (unsigned int) pc_range;
      *code_len = pc_range.57;
      <D.23098>:
      if (ex_info != 0B) goto <D.23100>; else goto <D.23101>;
      <D.23100>:
      *ex_info = 0B;
      *ex_info_len = 0;
      <D.23101>:
      if (aug_len != 0) goto <D.23102>; else goto <D.23103>;
      <D.23102>:
      {
        gint32 lsda_offset;
        guint8 * lsda;

        if (aug_len == 4) goto <D.23104>; else goto <D.23105>;
        <D.23104>:
        D.23106 = MEM[(const guint32 *)fde_aug];
        lsda_offset = (gint32) D.23106;
        goto <D.23107>;
        <D.23105>:
        if (aug_len == 8) goto <D.23108>; else goto <D.23109>;
        <D.23108>:
        D.23110 = MEM[(gint64 *)fde_aug];
        lsda_offset = (gint32) D.23110;
        goto <D.23111>;
        <D.23109>:
        monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "unwind.c", 929);
        <D.23111>:
        <D.23107>:
        if (lsda_offset != 0) goto <D.23112>; else goto <D.23113>;
        <D.23112>:
        D.23114 = (sizetype) lsda_offset;
        lsda = fde_aug + D.23114;
        decode_lsda (lsda, code, ex_info, ex_info_len, type_info, this_reg, this_offset);
        <D.23113>:
      }
      <D.23103>:
      D.23115 = code_align != 1;
      D.23116 = (long int) D.23115;
      D.23117 = __builtin_expect (D.23116, 0);
      if (D.23117 != 0) goto <D.23118>; else goto <D.23119>;
      <D.23118>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "unwind.c", 938, "code_align == 1");
      <D.23119>:
      D.23120 = data_align != -8;
      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", 939, "data_align == DWARF_DATA_ALIGN");
      <D.23124>:
      D.23125 = return_reg != 108;
      D.23126 = (long int) D.23125;
      D.23127 = __builtin_expect (D.23126, 0);
      if (D.23127 != 0) goto <D.23128>; else goto <D.23129>;
      <D.23128>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "unwind.c", 940, "return_reg == DWARF_PC_REG");
      <D.23129>:
      D.23130 = (sizetype) cie_len;
      D.23131 = D.23130 + 4;
      D.23132 = cie + D.23131;
      D.23133 = (long int) D.23132;
      cie_cfi.58 = (long int) cie_cfi;
      D.23135 = D.23133 - cie_cfi.58;
      D.23136 = (unsigned int) D.23135;
      D.23091 = (sizetype) fde_len;
      D.23092 = D.23091 + 4;
      D.23093 = fde + D.23092;
      D.23094 = (long int) D.23093;
      fde_cfi.59 = (long int) fde_cfi;
      D.23138 = D.23094 - fde_cfi.59;
      D.23139 = (unsigned int) D.23138;
      D.23140 = D.23136 + D.23139;
      buf_len = (gint32) D.23140;
      D.23141 = (long unsigned int) buf_len;
      buf = monoeg_malloc0 (D.23141);
      i = 0;
      p = cie_cfi;
      goto <D.22688>;
      <D.22687>:
      p.49 = p;
      D.23051 = *p.49;
      if (D.23051 == 0) goto <D.22686>; else goto <D.23142>;
      <D.23142>:
      p.49 = p;
      decode_cie_op (p.49, &p);
      <D.22688>:
      D.23130 = (sizetype) cie_len;
      D.23131 = D.23130 + 4;
      D.23132 = cie + D.23131;
      p.49 = p;
      if (D.23132 > p.49) goto <D.22687>; else goto <D.22686>;
      <D.22686>:
      D.23067 = (sizetype) i;
      D.23143 = buf + D.23067;
      p.49 = p;
      p.56 = (long int) p.49;
      cie_cfi.58 = (long int) cie_cfi;
      D.23144 = p.56 - cie_cfi.58;
      D.23145 = (long unsigned int) D.23144;
      memcpy (D.23143, cie_cfi, D.23145);
      p.49 = p;
      p.56 = (long int) p.49;
      cie_cfi.58 = (long int) cie_cfi;
      D.23144 = p.56 - cie_cfi.58;
      D.23146 = (unsigned int) D.23144;
      i.60 = (unsigned int) i;
      D.23148 = D.23146 + i.60;
      i = (gint32) D.23148;
      p = fde_cfi;
      goto <D.22691>;
      <D.22690>:
      p.49 = p;
      D.23051 = *p.49;
      if (D.23051 == 0) goto <D.22689>; else goto <D.23149>;
      <D.23149>:
      p.49 = p;
      decode_cie_op (p.49, &p);
      <D.22691>:
      D.23091 = (sizetype) fde_len;
      D.23092 = D.23091 + 4;
      D.23093 = fde + D.23092;
      p.49 = p;
      if (D.23093 > p.49) goto <D.22690>; else goto <D.22689>;
      <D.22689>:
      D.23067 = (sizetype) i;
      D.23143 = buf + D.23067;
      p.49 = p;
      p.56 = (long int) p.49;
      fde_cfi.59 = (long int) fde_cfi;
      D.23150 = p.56 - fde_cfi.59;
      D.23151 = (long unsigned int) D.23150;
      memcpy (D.23143, fde_cfi, D.23151);
      p.49 = p;
      p.56 = (long int) p.49;
      fde_cfi.59 = (long int) fde_cfi;
      D.23150 = p.56 - fde_cfi.59;
      D.23152 = (unsigned int) D.23150;
      i.60 = (unsigned int) i;
      D.23153 = D.23152 + i.60;
      i = (gint32) D.23153;
      D.23154 = i > buf_len;
      D.23155 = (long int) D.23154;
      D.23156 = __builtin_expect (D.23155, 0);
      if (D.23156 != 0) goto <D.23157>; else goto <D.23158>;
      <D.23157>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "unwind.c", 965, "i <= buf_len");
      <D.23158>:
      i.61 = (unsigned int) i;
      *out_len = i.61;
      D.23161 = (long unsigned int) i;
      D.23160 = monoeg_realloc (buf, D.23161);
      return D.23160;
    }
  finally
    {
      p = {CLOBBER};
    }
}


read_encoded_val (guint32 encoding, guint8 * p, guint8 * * endp)
{
  unsigned int D.23165;
  int D.23166;
  gint64 D.23167;
  gint64 res;

  D.23165 = encoding & 15;
  switch (D.23165) <default: <D.22612>, case 11: <D.22611>, case 12: <D.22609>>
  <D.22609>:
  res = MEM[(gint64 *)p];
  p = p + 8;
  goto <D.22610>;
  <D.22611>:
  D.23166 = MEM[(gint32 *)p];
  res = (gint64) D.23166;
  p = p + 4;
  goto <D.22610>;
  <D.22612>:
  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "unwind.c", 717);
  <D.22610>:
  *endp = p;
  D.23167 = res;
  return D.23167;
}


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.23170;
  long int D.23171;
  long int D.23172;
  _Bool D.23175;
  long int D.23176;
  long int D.23177;
  unsigned char D.23180;
  guint8 * p.63;
  _Bool D.23184;
  long int D.23185;
  long int D.23186;
  unsigned int D.23189;
  int D.23190;
  _Bool D.23192;
  long int D.23193;
  long int D.23194;
  unsigned int D.23197;
  long unsigned int p.64;
  long unsigned int D.23199;
  long unsigned int D.23200;
  guint8 * p.65;
  long unsigned int D.23204;
  long unsigned int D.23205;
  void * D.23206;
  unsigned int ncall_sites.66;
  long unsigned int D.23210;
  void * D.23211;
  unsigned int D.23212;
  guint8 * p.67;
  _Bool D.23214;
  long int D.23215;
  long int D.23216;
  long unsigned int tinfo.68;
  long unsigned int D.23220;
  _Bool D.23221;
  long int D.23222;
  long int D.23223;
  void * * D.23228;
  long unsigned int D.23231;
  long unsigned int D.23232;
  void * * D.23233;
  struct MonoJitExceptionInfo * D.23234;
  long unsigned int D.23235;
  struct MonoJitExceptionInfo * D.23236;
  sizetype D.23237;
  void * D.23238;
  sizetype D.23239;
  sizetype D.23240;
  guint8 * D.23241;
  sizetype D.23242;
  void * D.23243;
  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.23170 = mono_magic != 1297084239;
      D.23171 = (long int) D.23170;
      D.23172 = __builtin_expect (D.23171, 0);
      if (D.23172 != 0) goto <D.23173>; else goto <D.23174>;
      <D.23173>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "unwind.c", 740, "mono_magic == 0x4d4fef4f");
      <D.23174>:
      p.62 = p;
      version = decode_uleb128 (p.62, &p);
      D.23175 = version != 1;
      D.23176 = (long int) D.23175;
      D.23177 = __builtin_expect (D.23176, 0);
      if (D.23177 != 0) goto <D.23178>; else goto <D.23179>;
      <D.23178>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "unwind.c", 742, "version == 1");
      <D.23179>:
      p.62 = p;
      D.23180 = *p.62;
      this_encoding = (int) D.23180;
      p.62 = p;
      p.63 = p.62 + 1;
      p = p.63;
      if (this_encoding == 3) goto <D.23182>; else goto <D.23183>;
      <D.23182>:
      {
        gint32 op;
        gint32 reg;
        gint32 offset;

        p.62 = p;
        D.23180 = *p.62;
        op = (gint32) D.23180;
        D.23184 = op != 146;
        D.23185 = (long int) D.23184;
        D.23186 = __builtin_expect (D.23185, 0);
        if (D.23186 != 0) goto <D.23187>; else goto <D.23188>;
        <D.23187>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "unwind.c", 750, "op == DW_OP_bregx");
        <D.23188>:
        p.62 = p;
        p.63 = p.62 + 1;
        p = p.63;
        p.62 = p;
        D.23189 = decode_uleb128 (p.62, &p);
        reg = (gint32) D.23189;
        p.62 = p;
        offset = decode_sleb128 (p.62, &p);
        D.23190 = mono_dwarf_reg_to_hw_reg (reg);
        *this_reg = D.23190;
        *this_offset = offset;
      }
      goto <D.23191>;
      <D.23183>:
      D.23192 = this_encoding != 255;
      D.23193 = (long int) D.23192;
      D.23194 = __builtin_expect (D.23193, 0);
      if (D.23194 != 0) goto <D.23195>; else goto <D.23196>;
      <D.23195>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "unwind.c", 758, "this_encoding == DW_EH_PE_omit");
      <D.23196>:
      *this_reg = -1;
      *this_offset = -1;
      <D.23191>:
      p.62 = p;
      D.23197 = decode_uleb128 (p.62, &p);
      ncall_sites = (int) D.23197;
      p.62 = p;
      p.64 = (long unsigned int) p.62;
      D.23199 = p.64 + 3;
      D.23200 = D.23199 & 18446744073709551612;
      p.65 = (guint8 *) D.23200;
      p = p.65;
      if (ex_info != 0B) goto <D.23202>; else goto <D.23203>;
      <D.23202>:
      D.23204 = (long unsigned int) ncall_sites;
      D.23205 = D.23204 * 40;
      D.23206 = monoeg_malloc0 (D.23205);
      *ex_info = D.23206;
      ncall_sites.66 = (unsigned int) ncall_sites;
      *ex_info_len = ncall_sites.66;
      <D.23203>:
      if (type_info != 0B) goto <D.23208>; else goto <D.23209>;
      <D.23208>:
      D.23204 = (long unsigned int) ncall_sites;
      D.23210 = D.23204 * 8;
      D.23211 = monoeg_malloc0 (D.23210);
      *type_info = D.23211;
      <D.23209>:
      i = 0;
      goto <D.22636>;
      <D.22635>:
      {
        int block_start_offset;
        int block_size;
        int landing_pad;
        guint8 * tinfo;

        p.62 = p;
        D.23212 = MEM[(const guint32 *)p.62];
        block_start_offset = (int) D.23212;
        p.62 = p;
        p.67 = p.62 + 4;
        p = p.67;
        p.62 = p;
        D.23212 = MEM[(const guint32 *)p.62];
        block_size = (int) D.23212;
        p.62 = p;
        p.67 = p.62 + 4;
        p = p.67;
        p.62 = p;
        D.23212 = MEM[(const guint32 *)p.62];
        landing_pad = (int) D.23212;
        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.23214 = landing_pad == 0;
        D.23215 = (long int) D.23214;
        D.23216 = __builtin_expect (D.23215, 0);
        if (D.23216 != 0) goto <D.23217>; else goto <D.23218>;
        <D.23217>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "unwind.c", 786, "landing_pad");
        <D.23218>:
        tinfo.68 = (long unsigned int) tinfo;
        D.23220 = tinfo.68 & 3;
        D.23221 = D.23220 != 0;
        D.23222 = (long int) D.23221;
        D.23223 = __builtin_expect (D.23222, 0);
        if (D.23223 != 0) goto <D.23224>; else goto <D.23225>;
        <D.23224>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "unwind.c", 787, "((size_t)tinfo % 4) == 0");
        <D.23225>:
        if (ex_info != 0B) goto <D.23226>; else goto <D.23227>;
        <D.23226>:
        D.23228 = *type_info;
        if (D.23228 != 0B) goto <D.23229>; else goto <D.23230>;
        <D.23229>:
        D.23228 = *type_info;
        D.23231 = (long unsigned int) i;
        D.23232 = D.23231 * 8;
        D.23233 = D.23228 + D.23232;
        *D.23233 = tinfo;
        <D.23230>:
        D.23234 = *ex_info;
        D.23231 = (long unsigned int) i;
        D.23235 = D.23231 * 40;
        D.23236 = D.23234 + D.23235;
        D.23237 = (sizetype) block_start_offset;
        D.23238 = code + D.23237;
        D.23236->try_start = D.23238;
        D.23234 = *ex_info;
        D.23231 = (long unsigned int) i;
        D.23235 = D.23231 * 40;
        D.23236 = D.23234 + D.23235;
        D.23237 = (sizetype) block_start_offset;
        D.23239 = (sizetype) block_size;
        D.23240 = D.23237 + D.23239;
        D.23241 = code + D.23240;
        D.23236->try_end = D.23241;
        D.23234 = *ex_info;
        D.23231 = (long unsigned int) i;
        D.23235 = D.23231 * 40;
        D.23236 = D.23234 + D.23235;
        D.23242 = (sizetype) landing_pad;
        D.23243 = code + D.23242;
        D.23236->handler_start = D.23243;
        <D.23227>:
      }
      i = i + 1;
      <D.22636>:
      if (i < ncall_sites) goto <D.22635>; else goto <D.22637>;
      <D.22637>:
    }
  finally
    {
      p = {CLOBBER};
    }
}


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

  p.69 = p;
  D.23245 = *p.69;
  D.23246 = (int) D.23245;
  op = D.23246 & 192;
  switch (op) <default: <D.22602>, case 0: <D.22593>, case 64: <D.22590>, case 128: <D.22592>>
  <D.22590>:
  p.69 = p;
  p.70 = p.69 + 1;
  p = p.70;
  goto <D.22591>;
  <D.22592>:
  p.69 = p;
  p.70 = p.69 + 1;
  p = p.70;
  p.69 = p;
  decode_uleb128 (p.69, &p);
  goto <D.22591>;
  <D.22593>:
  {
    int ext_op;

    p.69 = p;
    D.23245 = *p.69;
    ext_op = (int) D.23245;
    p.69 = p;
    p.70 = p.69 + 1;
    p = p.70;
    switch (ext_op) <default: <D.22601>, case 4: <D.22599>, case 12: <D.22595>, case 13: <D.22598>, case 14: <D.22597>, case 17: <D.22600>>
    <D.22595>:
    p.69 = p;
    decode_uleb128 (p.69, &p);
    p.69 = p;
    decode_uleb128 (p.69, &p);
    goto <D.22596>;
    <D.22597>:
    p.69 = p;
    decode_uleb128 (p.69, &p);
    goto <D.22596>;
    <D.22598>:
    p.69 = p;
    decode_uleb128 (p.69, &p);
    goto <D.22596>;
    <D.22599>:
    p.69 = p;
    p.71 = p.69 + 4;
    p = p.71;
    goto <D.22596>;
    <D.22600>:
    p.69 = p;
    decode_uleb128 (p.69, &p);
    p.69 = p;
    decode_uleb128 (p.69, &p);
    goto <D.22596>;
    <D.22601>:
    monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "unwind.c", 691);
    <D.22596>:
    goto <D.22591>;
  }
  <D.22602>:
  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "unwind.c", 696);
  <D.22591>:
  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.23250;
  guint8 * p.73;
  unsigned int D.23254;
  guint8 * p.74;
  sizetype D.23257;
  guint8 * p.75;
  struct MonoJitExceptionInfo * * D.23261;
  guint32 * D.23262;
  void * * * D.23263;
  int * D.23264;
  int * D.23265;
  unsigned int D.23266;
  unsigned int D.23267;
  unsigned int pers_encoding.76;
  _Bool D.23271;
  long int D.23272;
  long int D.23273;
  _Bool D.23276;
  long int D.23277;
  long int D.23278;
  _Bool D.23281;
  long int D.23282;
  long int D.23283;
  long int p.77;
  long int cie_cfi.78;
  long int D.23289;
  sizetype D.23290;
  guint8 * D.23291;
  long int D.23292;
  long int fde_cfi.79;
  long int D.23294;
  int D.23295;
  long unsigned int D.23296;
  long unsigned int D.23297;
  sizetype D.23298;
  guint8 * D.23299;
  long unsigned int D.23300;
  unsigned int D.23301;
  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.23250 = *p.72;
      has_aug = (int) D.23250;
      p.72 = p;
      p.73 = p.72 + 1;
      p = p.73;
      if (has_aug != 0) goto <D.23252>; else goto <D.23253>;
      <D.23252>:
      p.72 = p;
      D.23254 = MEM[(const guint32 *)p.72];
      aug_len = (int) D.23254;
      p.72 = p;
      p.74 = p.72 + 4;
      p = p.74;
      goto <D.23256>;
      <D.23253>:
      aug_len = 0;
      <D.23256>:
      fde_aug = p;
      p.72 = p;
      D.23257 = (sizetype) aug_len;
      p.75 = p.72 + D.23257;
      p = p.75;
      fde_cfi = p;
      if (has_aug != 0) goto <D.23259>; else goto <D.23260>;
      <D.23259>:
      {
        guint8 * lsda;

        lsda = fde_aug;
        D.23261 = &res->ex_info;
        D.23262 = &res->ex_info_len;
        D.23263 = &res->type_info;
        D.23264 = &res->this_reg;
        D.23265 = &res->this_offset;
        decode_lsda (lsda, code, D.23261, D.23262, D.23263, D.23264, D.23265);
      }
      <D.23260>:
      p = cie;
      p.72 = p;
      D.23266 = decode_uleb128 (p.72, &p);
      code_align = (gint32) D.23266;
      p.72 = p;
      data_align = decode_sleb128 (p.72, &p);
      p.72 = p;
      D.23267 = decode_uleb128 (p.72, &p);
      return_reg = (gint32) D.23267;
      p.72 = p;
      D.23250 = *p.72;
      pers_encoding = (gint32) D.23250;
      p.72 = p;
      p.73 = p.72 + 1;
      p = p.73;
      if (pers_encoding != 255) goto <D.23268>; else goto <D.23269>;
      <D.23268>:
      pers_encoding.76 = (unsigned int) pers_encoding;
      p.72 = p;
      read_encoded_val (pers_encoding.76, p.72, &p);
      <D.23269>:
      cie_cfi = p;
      D.23271 = code_align != 1;
      D.23272 = (long int) D.23271;
      D.23273 = __builtin_expect (D.23272, 0);
      if (D.23273 != 0) goto <D.23274>; else goto <D.23275>;
      <D.23274>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "unwind.c", 1028, "code_align == 1");
      <D.23275>:
      D.23276 = data_align != -8;
      D.23277 = (long int) D.23276;
      D.23278 = __builtin_expect (D.23277, 0);
      if (D.23278 != 0) goto <D.23279>; else goto <D.23280>;
      <D.23279>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "unwind.c", 1029, "data_align == DWARF_DATA_ALIGN");
      <D.23280>:
      D.23281 = return_reg != 108;
      D.23282 = (long int) D.23281;
      D.23283 = __builtin_expect (D.23282, 0);
      if (D.23283 != 0) goto <D.23284>; else goto <D.23285>;
      <D.23284>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "unwind.c", 1030, "return_reg == DWARF_PC_REG");
      <D.23285>:
      p = cie_cfi;
      <D.22714>:
      p.72 = p;
      D.23250 = *p.72;
      if (D.23250 == 0) goto <D.22713>; else goto <D.23286>;
      <D.23286>:
      p.72 = p;
      decode_cie_op (p.72, &p);
      goto <D.22714>;
      <D.22713>:
      p.72 = p;
      p.77 = (long int) p.72;
      cie_cfi.78 = (long int) cie_cfi;
      D.23289 = p.77 - cie_cfi.78;
      cie_cfi_len = (int) D.23289;
      D.23290 = (sizetype) fde_len;
      D.23291 = fde + D.23290;
      D.23292 = (long int) D.23291;
      fde_cfi.79 = (long int) fde_cfi;
      D.23294 = D.23292 - fde_cfi.79;
      fde_cfi_len = (int) D.23294;
      D.23295 = cie_cfi_len + fde_cfi_len;
      D.23296 = (long unsigned int) D.23295;
      buf = monoeg_malloc0 (D.23296);
      D.23297 = (long unsigned int) cie_cfi_len;
      memcpy (buf, cie_cfi, D.23297);
      D.23298 = (sizetype) cie_cfi_len;
      D.23299 = buf + D.23298;
      D.23300 = (long unsigned int) fde_cfi_len;
      memcpy (D.23299, fde_cfi, D.23300);
      D.23295 = cie_cfi_len + fde_cfi_len;
      D.23301 = (unsigned int) D.23295;
      res->unw_info_len = D.23301;
      res->unw_info = buf;
    }
  finally
    {
      p = {CLOBBER};
    }
}


mono_unwind_get_cie_program ()
{
  struct GSList * D.23302;

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