mono_hw_reg_to_dwarf_reg (int reg)
{
  int D.21878;

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


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

  dwarf_reg_to_hw_reg_inited.0 = dwarf_reg_to_hw_reg_inited;
  if (dwarf_reg_to_hw_reg_inited.0 == 0) goto <D.21881>; else goto <D.21882>;
  <D.21881>:
  init_reg_map ();
  <D.21882>:
  D.21883 = map_dwarf_reg_to_hw_reg[reg];
  return D.21883;
}


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

  if (0 != 0) goto <D.21885>; else goto <D.21886>;
  <D.21885>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "unwind.c", 138, "NUM_REGS > 0");
  <D.21886>:
  i = 0;
  goto <D.21550>;
  <D.21549>:
  D.21887 = mono_hw_reg_to_dwarf_reg (i);
  map_dwarf_reg_to_hw_reg[D.21887] = i;
  i = i + 1;
  <D.21550>:
  i.1 = (unsigned int) i;
  if (i.1 <= 31) goto <D.21549>; else goto <D.21551>;
  <D.21551>:
  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.21890;
  int D.21891;
  int D.21892;
  guint8 * p.3;
  unsigned int D.21894;
  unsigned int D.21895;
  int D.21896;
  int D.21899;
  int D.21901;
  const char * D.21902;
  unsigned int D.21903;
  unsigned int D.21904;
  int D.21905;
  const char * D.21906;
  unsigned int D.21907;
  unsigned int D.21908;
  int D.21909;
  const char * D.21910;
  unsigned int D.21911;
  int D.21912;
  int D.21913;
  const char * D.21914;
  unsigned int D.21915;
  unsigned int pos.4;
  unsigned int D.21917;
  guint8 * p.5;
  sizetype unwind_info_len.6;
  guint8 * D.21920;
  guint8 * p;
  int pos;
  int reg;
  int offset;
  int cfa_reg;
  int cfa_offset;

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

        p.2 = p;
        D.21890 = *p.2;
        D.21891 = (int) D.21890;
        op = D.21891 & 192;
        switch (op) <default: <D.21620>, case 0: <D.21611>, case 64: <D.21608>, case 128: <D.21610>>
        <D.21608>:
        p.2 = p;
        D.21890 = *p.2;
        D.21891 = (int) D.21890;
        D.21892 = D.21891 & 63;
        pos = D.21892 + pos;
        p.2 = p;
        p.3 = p.2 + 1;
        p = p.3;
        goto <D.21609>;
        <D.21610>:
        p.2 = p;
        D.21890 = *p.2;
        D.21891 = (int) D.21890;
        reg = D.21891 & 63;
        p.2 = p;
        p.3 = p.2 + 1;
        p = p.3;
        p.2 = p;
        D.21894 = decode_uleb128 (p.2, &p);
        D.21895 = D.21894 * 4294967292;
        offset = (int) D.21895;
        D.21896 = mono_hw_reg_to_dwarf_reg (31);
        if (D.21896 == reg) goto <D.21897>; else goto <D.21898>;
        <D.21897>:
        D.21899 = -offset;
        printf ("CFA: [%x] offset: %s at cfa-0x%x\n", pos, "pc", D.21899);
        goto <D.21900>;
        <D.21898>:
        D.21901 = mono_dwarf_reg_to_hw_reg (reg);
        D.21902 = mono_arch_regname (D.21901);
        D.21899 = -offset;
        printf ("CFA: [%x] offset: %s at cfa-0x%x\n", pos, D.21902, D.21899);
        <D.21900>:
        goto <D.21609>;
        <D.21611>:
        {
          int ext_op;

          p.2 = p;
          D.21890 = *p.2;
          ext_op = (int) D.21890;
          p.2 = p;
          p.3 = p.2 + 1;
          p = p.3;
          switch (ext_op) <default: <D.21619>, case 4: <D.21618>, case 12: <D.21613>, case 13: <D.21616>, case 14: <D.21615>, case 17: <D.21617>>
          <D.21613>:
          p.2 = p;
          D.21903 = decode_uleb128 (p.2, &p);
          cfa_reg = (int) D.21903;
          p.2 = p;
          D.21904 = decode_uleb128 (p.2, &p);
          cfa_offset = (int) D.21904;
          D.21905 = mono_dwarf_reg_to_hw_reg (cfa_reg);
          D.21906 = mono_arch_regname (D.21905);
          printf ("CFA: [%x] def_cfa: %s+0x%x\n", pos, D.21906, cfa_offset);
          goto <D.21614>;
          <D.21615>:
          p.2 = p;
          D.21907 = decode_uleb128 (p.2, &p);
          cfa_offset = (int) D.21907;
          printf ("CFA: [%x] def_cfa_offset: 0x%x\n", pos, cfa_offset);
          goto <D.21614>;
          <D.21616>:
          p.2 = p;
          D.21908 = decode_uleb128 (p.2, &p);
          cfa_reg = (int) D.21908;
          D.21909 = mono_dwarf_reg_to_hw_reg (cfa_reg);
          D.21910 = mono_arch_regname (D.21909);
          printf ("CFA: [%x] def_cfa_reg: %s\n", pos, D.21910);
          goto <D.21614>;
          <D.21617>:
          p.2 = p;
          D.21911 = decode_uleb128 (p.2, &p);
          reg = (int) D.21911;
          p.2 = p;
          D.21912 = decode_sleb128 (p.2, &p);
          offset = D.21912 * -4;
          D.21913 = mono_dwarf_reg_to_hw_reg (reg);
          D.21914 = mono_arch_regname (D.21913);
          D.21899 = -offset;
          printf ("CFA: [%x] offset_extended_sf: %s at cfa-0x%x\n", pos, D.21914, D.21899);
          goto <D.21614>;
          <D.21618>:
          p.2 = p;
          D.21915 = mono_read32 (p.2);
          pos.4 = (unsigned int) pos;
          D.21917 = D.21915 + pos.4;
          pos = (int) D.21917;
          p.2 = p;
          p.5 = p.2 + 4;
          p = p.5;
          goto <D.21614>;
          <D.21619>:
          monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "unwind.c", 306);
          <D.21614>:
          goto <D.21609>;
        }
        <D.21620>:
        monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "unwind.c", 311);
        <D.21609>:
      }
      <D.21622>:
      unwind_info_len.6 = (sizetype) unwind_info_len;
      D.21920 = unwind_info + unwind_info_len.6;
      p.2 = p;
      if (D.21920 > p.2) goto <D.21621>; else goto <D.21623>;
      <D.21623>:
    }
  finally
    {
      p = {CLOBBER};
    }
}


decode_uleb128 (guint8 * buf, guint8 * * endbuf)
{
  int D.21921;
  int D.21922;
  int D.21923;
  unsigned int D.21924;
  signed char b.7;
  guint32 D.21927;
  guint8 * p;
  guint32 res;
  int shift;

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

    b = *p;
    p = p + 1;
    D.21921 = (int) b;
    D.21922 = D.21921 & 127;
    D.21923 = D.21922 << shift;
    D.21924 = (unsigned int) D.21923;
    res = D.21924 | res;
    b.7 = (signed char) b;
    if (b.7 >= 0) goto <D.21585>; else goto <D.21926>;
    <D.21926>:
    shift = shift + 7;
  }
  goto <D.21586>;
  <D.21585>:
  *endbuf = p;
  D.21927 = res;
  return D.21927;
}


decode_sleb128 (guint8 * buf, guint8 * * endbuf)
{
  int D.21929;
  int D.21930;
  int D.21931;
  signed char b.8;
  int D.21937;
  int D.21940;
  int D.21941;
  gint32 D.21942;
  guint8 * p;
  gint32 res;
  int shift;

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

    b = *p;
    p = p + 1;
    D.21929 = (int) b;
    D.21930 = D.21929 & 127;
    D.21931 = D.21930 << shift;
    res = D.21931 | res;
    shift = shift + 7;
    b.8 = (signed char) b;
    if (b.8 >= 0) goto <D.21933>; else goto <D.21934>;
    <D.21933>:
    if (shift <= 31) goto <D.21935>; else goto <D.21936>;
    <D.21935>:
    D.21929 = (int) b;
    D.21937 = D.21929 & 64;
    if (D.21937 != 0) goto <D.21938>; else goto <D.21939>;
    <D.21938>:
    D.21940 = 1 << shift;
    D.21941 = -D.21940;
    res = D.21941 | res;
    <D.21939>:
    <D.21936>:
    goto <D.21595>;
    <D.21934>:
  }
  goto <D.21596>;
  <D.21595>:
  *endbuf = p;
  D.21942 = res;
  return D.21942;
}


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

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


mono_unwind_ops_encode (struct GSList * unwind_ops, guint32 * out_len)
{
  short unsigned int D.21946;
  int D.21947;
  unsigned int D.21948;
  unsigned int loc.9;
  unsigned int D.21950;
  guint8 * p.10;
  guint8 * p.11;
  guint8 * p.12;
  unsigned char D.21956;
  unsigned char D.21957;
  unsigned char D.21958;
  unsigned char D.21959;
  guint8 * p.13;
  guint8 * p.14;
  unsigned char D.21963;
  int D.21964;
  guint8 * p.15;
  guint8 * p.16;
  unsigned int reg.17;
  int D.21968;
  unsigned int D.21969;
  guint8 * p.18;
  guint8 * p.19;
  guint8 * p.20;
  guint8 * p.21;
  guint8 * p.22;
  guint8 * p.23;
  int D.21978;
  guint8 * p.24;
  guint8 * p.25;
  signed char D.21982;
  signed char D.21983;
  unsigned char D.21984;
  unsigned int D.21985;
  int p.26;
  int buf.27;
  int D.21988;
  _Bool D.21989;
  long int D.21990;
  long int D.21991;
  unsigned int D.21994;
  unsigned int D.21995;
  unsigned int D.21996;
  guint8 * D.21997;
  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.21645>;
      <D.21644>:
      {
        int reg;

        op = l->data;
        D.21946 = op->reg;
        D.21947 = (int) D.21946;
        reg = mono_hw_reg_to_dwarf_reg (D.21947);
        goto <D.21636>;
        <D.21635>:
        D.21948 = op->when;
        loc.9 = (unsigned int) loc;
        D.21950 = D.21948 - loc.9;
        if (D.21950 <= 31) goto <D.21951>; else goto <D.21952>;
        <D.21951>:
        p.10 = p;
        p.11 = p.10;
        p.12 = p.11 + 1;
        p = p.12;
        D.21948 = op->when;
        D.21956 = (unsigned char) D.21948;
        D.21957 = (unsigned char) loc;
        D.21958 = D.21956 - D.21957;
        D.21959 = D.21958 | 64;
        *p.11 = D.21959;
        D.21948 = op->when;
        loc = (int) D.21948;
        goto <D.21960>;
        <D.21952>:
        p.10 = p;
        p.13 = p.10;
        p.14 = p.13 + 1;
        p = p.14;
        *p.13 = 94;
        loc = loc + 30;
        <D.21960>:
        <D.21636>:
        D.21948 = op->when;
        loc.9 = (unsigned int) loc;
        if (D.21948 > loc.9) goto <D.21635>; else goto <D.21637>;
        <D.21637>:
        D.21963 = op->op;
        D.21964 = (int) D.21963;
        switch (D.21964) <default: <D.21643>, case 12: <D.21638>, case 13: <D.21641>, case 14: <D.21640>, case 128: <D.21642>>
        <D.21638>:
        p.10 = p;
        p.15 = p.10;
        p.16 = p.15 + 1;
        p = p.16;
        D.21963 = op->op;
        *p.15 = D.21963;
        reg.17 = (unsigned int) reg;
        p.10 = p;
        encode_uleb128 (reg.17, p.10, &p);
        D.21968 = op->val;
        D.21969 = (unsigned int) D.21968;
        p.10 = p;
        encode_uleb128 (D.21969, p.10, &p);
        goto <D.21639>;
        <D.21640>:
        p.10 = p;
        p.18 = p.10;
        p.19 = p.18 + 1;
        p = p.19;
        D.21963 = op->op;
        *p.18 = D.21963;
        D.21968 = op->val;
        D.21969 = (unsigned int) D.21968;
        p.10 = p;
        encode_uleb128 (D.21969, p.10, &p);
        goto <D.21639>;
        <D.21641>:
        p.10 = p;
        p.20 = p.10;
        p.21 = p.20 + 1;
        p = p.21;
        D.21963 = op->op;
        *p.20 = D.21963;
        reg.17 = (unsigned int) reg;
        p.10 = p;
        encode_uleb128 (reg.17, p.10, &p);
        goto <D.21639>;
        <D.21642>:
        if (reg > 63) goto <D.21974>; else goto <D.21975>;
        <D.21974>:
        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.21968 = op->val;
        D.21978 = D.21968 / -4;
        p.10 = p;
        encode_sleb128 (D.21978, p.10, &p);
        goto <D.21979>;
        <D.21975>:
        p.10 = p;
        p.24 = p.10;
        p.25 = p.24 + 1;
        p = p.25;
        D.21982 = (signed char) reg;
        D.21983 = D.21982 | -128;
        D.21984 = (unsigned char) D.21983;
        *p.24 = D.21984;
        D.21968 = op->val;
        D.21978 = D.21968 / -4;
        D.21985 = (unsigned int) D.21978;
        p.10 = p;
        encode_uleb128 (D.21985, p.10, &p);
        <D.21979>:
        goto <D.21639>;
        <D.21643>:
        monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "unwind.c", 378);
        <D.21639>:
      }
      l = l->next;
      <D.21645>:
      if (l != 0B) goto <D.21644>; else goto <D.21646>;
      <D.21646>:
      p.10 = p;
      p.26 = (int) p.10;
      buf.27 = (int) buf;
      D.21988 = p.26 - buf.27;
      D.21989 = D.21988 > 4095;
      D.21990 = (long int) D.21989;
      D.21991 = __builtin_expect (D.21990, 0);
      if (D.21991 != 0) goto <D.21992>; else goto <D.21993>;
      <D.21992>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "unwind.c", 383, "p - buf < 4096");
      <D.21993>:
      p.10 = p;
      p.26 = (int) p.10;
      buf.27 = (int) buf;
      D.21988 = p.26 - buf.27;
      D.21994 = (unsigned int) D.21988;
      *out_len = D.21994;
      p.10 = p;
      p.26 = (int) p.10;
      buf.27 = (int) buf;
      D.21988 = p.26 - buf.27;
      D.21995 = (unsigned int) D.21988;
      res = monoeg_malloc (D.21995);
      p.10 = p;
      p.26 = (int) p.10;
      buf.27 = (int) buf;
      D.21988 = p.26 - buf.27;
      D.21996 = (unsigned int) D.21988;
      memcpy (res, buf, D.21996);
      monoeg_g_free (buf);
      D.21997 = res;
      return D.21997;
    }
  finally
    {
      p = {CLOBBER};
    }
}


encode_sleb128 (gint32 value, guint8 * buf, guint8 * * endbuf)
{
  _Bool D.22000;
  unsigned char D.22001;
  unsigned int D.22004;
  int D.22005;
  int D.22006;
  int D.22007;
  int D.22013;
  int D.22014;
  guint8 * p.28;
  gboolean more;
  gboolean negative;
  guint32 size;
  guint8 byte;
  guint8 * p;

  more = 1;
  D.22000 = value < 0;
  negative = (gboolean) D.22000;
  size = 32;
  p = buf;
  goto <D.21575>;
  <D.21574>:
  D.22001 = (unsigned char) value;
  byte = D.22001 & 127;
  value = value >> 7;
  if (negative != 0) goto <D.22002>; else goto <D.22003>;
  <D.22002>:
  D.22004 = size + 4294967289;
  D.22005 = (int) D.22004;
  D.22006 = 1 << D.22005;
  D.22007 = -D.22006;
  value = D.22007 | value;
  <D.22003>:
  if (value == 0) goto <D.22012>; else goto <D.22008>;
  <D.22012>:
  D.22013 = (int) byte;
  D.22014 = D.22013 & 64;
  if (D.22014 == 0) goto <D.22009>; else goto <D.22008>;
  <D.22008>:
  if (value == -1) goto <D.22015>; else goto <D.22010>;
  <D.22015>:
  D.22013 = (int) byte;
  D.22014 = D.22013 & 64;
  if (D.22014 != 0) goto <D.22009>; else goto <D.22010>;
  <D.22009>:
  more = 0;
  goto <D.22011>;
  <D.22010>:
  byte = byte | 128;
  <D.22011>:
  p.28 = p;
  p = p.28 + 1;
  *p.28 = byte;
  <D.21575>:
  if (more != 0) goto <D.21574>; else goto <D.21576>;
  <D.21576>:
  *endbuf = p;
}


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

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

    D.22017 = (unsigned char) value;
    b = D.22017 & 127;
    value = value >> 7;
    if (value != 0) goto <D.22018>; else goto <D.22019>;
    <D.22018>:
    b = b | 128;
    <D.22019>:
    p.29 = p;
    p = p.29 + 1;
    *p.29 = b;
  }
  if (value != 0) goto <D.21562>; else goto <D.21563>;
  <D.21563>:
  *endbuf = p;
}


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

  D.22022 = __builtin_object_size (__dest, 0);
  D.22021 = __builtin___memcpy_chk (__dest, __src, __len, D.22022);
  return D.22021;
}


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.22025;
  int D.22026;
  int D.22027;
  guint8 * p.31;
  unsigned int D.22029;
  unsigned int D.22030;
  int D.22031;
  unsigned int D.22032;
  unsigned int D.22033;
  unsigned int D.22034;
  unsigned int D.22035;
  unsigned int D.22036;
  _Bool D.22037;
  long int D.22038;
  long int D.22039;
  int D.22042;
  unsigned int D.22043;
  unsigned int D.22044;
  unsigned int D.22047;
  unsigned int pos.32;
  unsigned int D.22049;
  guint8 * p.33;
  int ip.34;
  int start_ip.35;
  int D.22053;
  guint8 * D.22055;
  unsigned int save_locations_len.36;
  unsigned int D.22059;
  int D.22060;
  unsigned int D.22061;
  unsigned int D.22062;
  mgreg_t * D.22063;
  int D.22064;
  sizetype D.22065;
  sizetype cfa_offset.37;
  sizetype D.22067;
  unsigned char D.22068;
  <unnamed type> D.22071;
  _Bool D.22074;
  long int D.22075;
  long int D.22076;
  unsigned int hreg.38;
  unsigned int D.22080;
  mgreg_t * D.22081;
  int D.22082;
  sizetype D.22083;
  mgreg_t * D.22084;
  int D.22085;
  mgreg_t * * D.22090;
  struct Loc locations[32];
  guint8 reg_saved[32];
  int i;
  int pos;
  int reg;
  int cfa_reg;
  int cfa_offset;
  int offset;
  guint8 * p;
  guint8 * cfa_val;

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

        p.30 = p;
        D.22025 = *p.30;
        D.22026 = (int) D.22025;
        op = D.22026 & 192;
        switch (op) <default: <D.21695>, case 0: <D.21685>, case 64: <D.21682>, case 128: <D.21684>>
        <D.21682>:
        p.30 = p;
        D.22025 = *p.30;
        D.22026 = (int) D.22025;
        D.22027 = D.22026 & 63;
        pos = D.22027 + pos;
        p.30 = p;
        p.31 = p.30 + 1;
        p = p.31;
        goto <D.21683>;
        <D.21684>:
        p.30 = p;
        D.22025 = *p.30;
        D.22026 = (int) D.22025;
        reg = D.22026 & 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.22029 = decode_uleb128 (p.30, &p);
        D.22030 = D.22029 * 4294967292;
        D.22031 = (int) D.22030;
        locations[reg].offset = D.22031;
        goto <D.21683>;
        <D.21685>:
        {
          int ext_op;

          p.30 = p;
          D.22025 = *p.30;
          ext_op = (int) D.22025;
          p.30 = p;
          p.31 = p.30 + 1;
          p = p.31;
          switch (ext_op) <default: <D.21694>, case 4: <D.21693>, case 5: <D.21692>, case 12: <D.21687>, case 13: <D.21690>, case 14: <D.21689>, case 17: <D.21691>>
          <D.21687>:
          p.30 = p;
          D.22032 = decode_uleb128 (p.30, &p);
          cfa_reg = (int) D.22032;
          p.30 = p;
          D.22033 = decode_uleb128 (p.30, &p);
          cfa_offset = (int) D.22033;
          goto <D.21688>;
          <D.21689>:
          p.30 = p;
          D.22034 = decode_uleb128 (p.30, &p);
          cfa_offset = (int) D.22034;
          goto <D.21688>;
          <D.21690>:
          p.30 = p;
          D.22035 = decode_uleb128 (p.30, &p);
          cfa_reg = (int) D.22035;
          goto <D.21688>;
          <D.21691>:
          p.30 = p;
          D.22036 = decode_uleb128 (p.30, &p);
          reg = (int) D.22036;
          p.30 = p;
          offset = decode_sleb128 (p.30, &p);
          D.22037 = reg > 31;
          D.22038 = (long int) D.22037;
          D.22039 = __builtin_expect (D.22038, 0);
          if (D.22039 != 0) goto <D.22040>; else goto <D.22041>;
          <D.22040>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "unwind.c", 470, "reg < NUM_REGS");
          <D.22041>:
          reg_saved[reg] = 1;
          locations[reg].loc_type = 1;
          D.22042 = offset * -4;
          locations[reg].offset = D.22042;
          goto <D.21688>;
          <D.21692>:
          p.30 = p;
          D.22043 = decode_uleb128 (p.30, &p);
          reg = (int) D.22043;
          p.30 = p;
          D.22044 = decode_uleb128 (p.30, &p);
          offset = (int) D.22044;
          D.22037 = reg > 31;
          D.22038 = (long int) D.22037;
          D.22039 = __builtin_expect (D.22038, 0);
          if (D.22039 != 0) goto <D.22045>; else goto <D.22046>;
          <D.22045>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "unwind.c", 478, "reg < NUM_REGS");
          <D.22046>:
          reg_saved[reg] = 1;
          locations[reg].loc_type = 1;
          D.22042 = offset * -4;
          locations[reg].offset = D.22042;
          goto <D.21688>;
          <D.21693>:
          p.30 = p;
          D.22047 = mono_read32 (p.30);
          pos.32 = (unsigned int) pos;
          D.22049 = D.22047 + pos.32;
          pos = (int) D.22049;
          p.30 = p;
          p.33 = p.30 + 4;
          p = p.33;
          goto <D.21688>;
          <D.21694>:
          monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "unwind.c", 488);
          <D.21688>:
          goto <D.21683>;
        }
        <D.21695>:
        monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "unwind.c", 493);
        <D.21683>:
      }
      <D.21697>:
      ip.34 = (int) ip;
      start_ip.35 = (int) start_ip;
      D.22053 = ip.34 - start_ip.35;
      if (D.22053 >= pos) goto <D.22054>; else goto <D.21698>;
      <D.22054>:
      D.22055 = unwind_info + unwind_info_len;
      p.30 = p;
      if (D.22055 > p.30) goto <D.21696>; else goto <D.21698>;
      <D.21698>:
      if (save_locations != 0B) goto <D.22056>; else goto <D.22057>;
      <D.22056>:
      save_locations_len.36 = (unsigned int) save_locations_len;
      D.22059 = save_locations_len.36 * 4;
      memset (save_locations, 0, D.22059);
      <D.22057>:
      D.22060 = mono_dwarf_reg_to_hw_reg (cfa_reg);
      D.22061 = (unsigned int) D.22060;
      D.22062 = D.22061 * 4;
      D.22063 = regs + D.22062;
      D.22064 = *D.22063;
      D.22065 = (sizetype) D.22064;
      cfa_offset.37 = (sizetype) cfa_offset;
      D.22067 = D.22065 + cfa_offset.37;
      cfa_val = (guint8 *) D.22067;
      i = 0;
      goto <D.21701>;
      <D.21700>:
      D.22068 = reg_saved[i];
      if (D.22068 != 0) goto <D.22069>; else goto <D.22070>;
      <D.22069>:
      D.22071 = locations[i].loc_type;
      if (D.22071 == 1) goto <D.22072>; else goto <D.22073>;
      <D.22072>:
      {
        int hreg;

        hreg = mono_dwarf_reg_to_hw_reg (i);
        D.22074 = hreg >= nregs;
        D.22075 = (long int) D.22074;
        D.22076 = __builtin_expect (D.22075, 0);
        if (D.22076 != 0) goto <D.22077>; else goto <D.22078>;
        <D.22077>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "unwind.c", 504, "hreg < nregs");
        <D.22078>:
        hreg.38 = (unsigned int) hreg;
        D.22080 = hreg.38 * 4;
        D.22081 = regs + D.22080;
        D.22082 = locations[i].offset;
        D.22083 = (sizetype) D.22082;
        D.22084 = cfa_val + D.22083;
        D.22085 = *D.22084;
        *D.22081 = D.22085;
        if (save_locations != 0B) goto <D.22086>; else goto <D.22087>;
        <D.22086>:
        if (hreg < save_locations_len) goto <D.22088>; else goto <D.22089>;
        <D.22088>:
        hreg.38 = (unsigned int) hreg;
        D.22080 = hreg.38 * 4;
        D.22090 = save_locations + D.22080;
        D.22082 = locations[i].offset;
        D.22083 = (sizetype) D.22082;
        D.22084 = cfa_val + D.22083;
        *D.22090 = D.22084;
        <D.22089>:
        <D.22087>:
      }
      <D.22073>:
      <D.22070>:
      i = i + 1;
      <D.21701>:
      if (i <= 31) goto <D.21700>; else goto <D.21702>;
      <D.21702>:
      *out_cfa = cfa_val;
    }
  finally
    {
      locations = {CLOBBER};
      reg_saved = {CLOBBER};
      p = {CLOBBER};
    }
}


memset (void * __dest, int __ch, size_t __len)
{
  int D.22093;
  int D.22098;
  void * D.22100;
  unsigned int D.22101;

  D.22093 = __builtin_constant_p (__len);
  if (D.22093 != 0) goto <D.22094>; else goto <D.22095>;
  <D.22094>:
  if (__len == 0) goto <D.22096>; else goto <D.22097>;
  <D.22096>:
  D.22098 = __builtin_constant_p (__ch);
  if (D.22098 == 0) goto <D.22091>; else goto <D.22099>;
  <D.22099>:
  if (__ch != 0) goto <D.22091>; else goto <D.22092>;
  <D.22091>:
  __warn_memset_zero_len ();
  D.22100 = __dest;
  return D.22100;
  <D.22092>:
  <D.22097>:
  <D.22095>:
  D.22101 = __builtin_object_size (__dest, 0);
  D.22100 = __builtin___memset_chk (__dest, __ch, __len, D.22101);
  return D.22100;
}


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.22107;
  struct MonoUnwindInfo * * D.22108;
  int cached_info_next.41;
  int i;

  DeleteCriticalSection (&unwind_mutex);
  cached_info.39 = cached_info;
  if (cached_info.39 == 0B) goto <D.22104>; else goto <D.22105>;
  <D.22104>:
  return;
  <D.22105>:
  i = 0;
  goto <D.21712>;
  <D.21711>:
  {
    struct MonoUnwindInfo * cached;

    cached_info.39 = cached_info;
    i.40 = (unsigned int) i;
    D.22107 = i.40 * 4;
    D.22108 = cached_info.39 + D.22107;
    cached = *D.22108;
    monoeg_g_free (cached);
  }
  i = i + 1;
  <D.21712>:
  cached_info_next.41 = cached_info_next;
  if (i < cached_info_next.41) goto <D.21711>; else goto <D.21713>;
  <D.21713>:
  cached_info.39 = cached_info;
  monoeg_g_free (cached_info.39);
}


mono_cache_unwind_info (guint8 * unwind_info, guint32 unwind_info_len)
{
  _Bool D.22113;
  long int D.22114;
  long int D.22115;
  struct MonoUnwindInfo * * cached_info.42;
  int cached_info_size.43;
  unsigned int cached_info_size.44;
  unsigned int D.22123;
  void * cached_info.45;
  unsigned int i.46;
  unsigned int D.22126;
  struct MonoUnwindInfo * * D.22127;
  unsigned int D.22128;
  guint8[0:] * D.22131;
  int D.22132;
  _Bool D.22137;
  long int D.22138;
  long int D.22139;
  guint32 D.22142;
  int cached_info_next.47;
  unsigned int D.22144;
  guint8[0:] * D.22145;
  unsigned int D.22148;
  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.22155;
  struct MonoUnwindInfo * * D.22156;
  int unwind_info_size.54;
  unsigned int unwind_info_size.55;
  unsigned int D.22159;
  unsigned int D.22160;
  int unwind_info_size.56;
  _Bool D.22164;
  long int D.22165;
  long int D.22166;
  int i;
  struct MonoUnwindInfo * info;

  {
    int ret;

    ret = pthread_mutex_lock (&unwind_mutex.mutex);
    if (ret != 0) goto <D.22111>; else goto <D.22112>;
    <D.22111>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
    <D.22112>:
    D.22113 = ret != 0;
    D.22114 = (long int) D.22113;
    D.22115 = __builtin_expect (D.22114, 0);
    if (D.22115 != 0) goto <D.22116>; else goto <D.22117>;
    <D.22116>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "unwind.c", 557, "ret == 0");
    <D.22117>:
  }
  cached_info.42 = cached_info;
  if (cached_info.42 == 0B) goto <D.22119>; else goto <D.22120>;
  <D.22119>:
  cached_info_size = 16;
  cached_info_size.43 = cached_info_size;
  cached_info_size.44 = (unsigned int) cached_info_size.43;
  D.22123 = cached_info_size.44 * 4;
  cached_info.45 = monoeg_malloc0 (D.22123);
  cached_info = cached_info.45;
  <D.22120>:
  i = 0;
  goto <D.21724>;
  <D.21723>:
  {
    struct MonoUnwindInfo * cached;

    cached_info.42 = cached_info;
    i.46 = (unsigned int) i;
    D.22126 = i.46 * 4;
    D.22127 = cached_info.42 + D.22126;
    cached = *D.22127;
    D.22128 = cached->len;
    if (D.22128 == unwind_info_len) goto <D.22129>; else goto <D.22130>;
    <D.22129>:
    D.22131 = &cached->info;
    D.22132 = memcmp (D.22131, unwind_info, unwind_info_len);
    if (D.22132 == 0) goto <D.22133>; else goto <D.22134>;
    <D.22133>:
    {
      int ret;

      ret = pthread_mutex_unlock (&unwind_mutex.mutex);
      if (ret != 0) goto <D.22135>; else goto <D.22136>;
      <D.22135>:
      monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
      <D.22136>:
      D.22137 = ret != 0;
      D.22138 = (long int) D.22137;
      D.22139 = __builtin_expect (D.22138, 0);
      if (D.22139 != 0) goto <D.22140>; else goto <D.22141>;
      <D.22140>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "unwind.c", 568, "ret == 0");
      <D.22141>:
    }
    D.22142 = (guint32) i;
    return D.22142;
    <D.22134>:
    <D.22130>:
  }
  i = i + 1;
  <D.21724>:
  cached_info_next.47 = cached_info_next;
  if (i < cached_info_next.47) goto <D.21723>; else goto <D.21725>;
  <D.21725>:
  D.22144 = unwind_info_len + 4;
  info = monoeg_malloc (D.22144);
  info->len = unwind_info_len;
  D.22145 = &info->info;
  memcpy (D.22145, 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.22146>; else goto <D.22147>;
  <D.22146>:
  {
    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.22148 = cached_info_size.44 * 8;
    new_table = monoeg_malloc0 (D.22148);
    cached_info.42 = cached_info;
    cached_info_size.43 = cached_info_size;
    cached_info_size.44 = (unsigned int) cached_info_size.43;
    D.22123 = cached_info_size.44 * 4;
    memcpy (new_table, cached_info.42, D.22123);
    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.22147>:
  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.22155 = cached_info_next.53 * 4;
  D.22156 = cached_info.42 + D.22155;
  *D.22156 = info;
  unwind_info_size.54 = unwind_info_size;
  unwind_info_size.55 = (unsigned int) unwind_info_size.54;
  D.22159 = unwind_info_len + unwind_info_size.55;
  D.22160 = D.22159 + 4;
  unwind_info_size.56 = (int) D.22160;
  unwind_info_size = unwind_info_size.56;
  {
    int ret;

    ret = pthread_mutex_unlock (&unwind_mutex.mutex);
    if (ret != 0) goto <D.22162>; else goto <D.22163>;
    <D.22162>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.22163>:
    D.22164 = ret != 0;
    D.22165 = (long int) D.22164;
    D.22166 = __builtin_expect (D.22165, 0);
    if (D.22166 != 0) goto <D.22167>; else goto <D.22168>;
    <D.22167>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "unwind.c", 605, "ret == 0");
    <D.22168>:
  }
  D.22142 = (guint32) i;
  return D.22142;
}


mono_get_cached_unwind_info (guint32 index, guint32 * unwind_info_len)
{
  unsigned int D.22170;
  struct MonoUnwindInfo * * D.22171;
  unsigned int D.22172;
  guint8 * D.22173;
  struct MonoUnwindInfo * * table;
  struct MonoUnwindInfo * info;
  guint8 * data;

  table = cached_info;
  D.22170 = index * 4;
  D.22171 = table + D.22170;
  info = *D.22171;
  D.22172 = info->len;
  *unwind_info_len = D.22172;
  data = &info->info;
  D.22173 = data;
  return D.22173;
}


mono_unwind_get_dwarf_data_align ()
{
  int D.22175;

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


mono_unwind_get_dwarf_pc_reg ()
{
  int D.22177;

  D.22177 = mono_hw_reg_to_dwarf_reg (31);
  return D.22177;
}


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.22180;
  unsigned int fde_len.58;
  unsigned int D.22182;
  _Bool D.22183;
  long int D.22184;
  long int D.22185;
  guint8 * p.59;
  sizetype cie_offset.60;
  sizetype D.22190;
  _Bool D.22191;
  long int D.22192;
  long int D.22193;
  unsigned char D.22196;
  _Bool D.22197;
  long int D.22198;
  long int D.22199;
  guint8 * p.61;
  unsigned int D.22203;
  sizetype D.22204;
  guint8 * p.62;
  unsigned int D.22206;
  unsigned int D.22207;
  char * D.22208;
  unsigned int D.22211;
  sizetype i.63;
  char * D.22213;
  char D.22214;
  int D.22215;
  unsigned char D.22216;
  _Bool D.22217;
  long int D.22218;
  long int D.22219;
  _Bool D.22222;
  long int D.22223;
  long int D.22224;
  sizetype cie_aug_len.64;
  guint8 * p.65;
  sizetype pc_begin.66;
  unsigned int D.22232;
  sizetype aug_len.67;
  guint8 * p.68;
  sizetype fde_len.69;
  sizetype D.22237;
  guint8 * D.22238;
  int D.22239;
  int p.70;
  unsigned int pc_range.71;
  unsigned int D.22250;
  long long int D.22254;
  sizetype lsda_offset.72;
  _Bool D.22259;
  long int D.22260;
  long int D.22261;
  _Bool D.22264;
  long int D.22265;
  long int D.22266;
  int D.22269;
  _Bool D.22270;
  long int D.22271;
  long int D.22272;
  sizetype cie_len.73;
  sizetype D.22276;
  guint8 * D.22277;
  int D.22278;
  int cie_cfi.74;
  int D.22280;
  int fde_cfi.75;
  int D.22282;
  unsigned int buf_len.76;
  guint8 * D.22285;
  int D.22286;
  unsigned int D.22287;
  int D.22289;
  unsigned int D.22290;
  _Bool D.22291;
  long int D.22292;
  long int D.22293;
  unsigned int i.77;
  guint8 * D.22297;
  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.22180 = MEM[(guint32 *)p.57];
      fde_len = (gint32) D.22180;
      fde_len.58 = (unsigned int) fde_len;
      D.22182 = fde_len.58 + 1;
      D.22183 = D.22182 <= 1;
      D.22184 = (long int) D.22183;
      D.22185 = __builtin_expect (D.22184, 0);
      if (D.22185 != 0) goto <D.22186>; else goto <D.22187>;
      <D.22186>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "unwind.c", 833, "fde_len != 0xffffffff && fde_len != 0");
      <D.22187>:
      p.57 = p;
      p.59 = p.57 + 4;
      p = p.59;
      p.57 = p;
      D.22180 = MEM[(guint32 *)p.57];
      cie_offset = (gint32) D.22180;
      p.57 = p;
      cie_offset.60 = (sizetype) cie_offset;
      D.22190 = -cie_offset.60;
      cie = p.57 + D.22190;
      p.57 = p;
      p.59 = p.57 + 4;
      p = p.59;
      fde_current = p;
      p = cie;
      p.57 = p;
      D.22180 = MEM[(guint32 *)p.57];
      cie_len = (gint32) D.22180;
      p.57 = p;
      p.59 = p.57 + 4;
      p = p.59;
      p.57 = p;
      D.22180 = MEM[(guint32 *)p.57];
      cie_id = (gint32) D.22180;
      D.22191 = cie_id != 0;
      D.22192 = (long int) D.22191;
      D.22193 = __builtin_expect (D.22192, 0);
      if (D.22193 != 0) goto <D.22194>; else goto <D.22195>;
      <D.22194>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "unwind.c", 845, "cie_id == 0");
      <D.22195>:
      p.57 = p;
      p.59 = p.57 + 4;
      p = p.59;
      p.57 = p;
      D.22196 = *p.57;
      cie_version = (gint32) D.22196;
      D.22197 = cie_version != 1;
      D.22198 = (long int) D.22197;
      D.22199 = __builtin_expect (D.22198, 0);
      if (D.22199 != 0) goto <D.22200>; else goto <D.22201>;
      <D.22200>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "unwind.c", 848, "cie_version == 1");
      <D.22201>:
      p.57 = p;
      p.61 = p.57 + 1;
      p = p.61;
      cie_aug_str = p;
      p.57 = p;
      D.22203 = strlen (cie_aug_str);
      D.22204 = D.22203 + 1;
      p.62 = p.57 + D.22204;
      p = p.62;
      p.57 = p;
      D.22206 = decode_uleb128 (p.57, &p);
      code_align = (gint32) D.22206;
      p.57 = p;
      data_align = decode_sleb128 (p.57, &p);
      p.57 = p;
      D.22207 = decode_uleb128 (p.57, &p);
      return_reg = (gint32) D.22207;
      D.22208 = __builtin_strchr (cie_aug_str, 122);
      if (D.22208 != 0B) goto <D.22209>; else goto <D.22210>;
      <D.22209>:
      {
        guint8 * cie_aug;
        guint32 p_encoding;

        p.57 = p;
        D.22211 = decode_uleb128 (p.57, &p);
        cie_aug_len = (gint32) D.22211;
        has_fde_augmentation = 1;
        cie_aug = p;
        i = 0;
        goto <D.21839>;
        <D.21838>:
        i.63 = (sizetype) i;
        D.22213 = cie_aug_str + i.63;
        D.22214 = *D.22213;
        D.22215 = (int) D.22214;
        switch (D.22215) <default: <D.21837>, case 76: <D.21835>, case 80: <D.21834>, case 82: <D.21836>, case 122: <D.21832>>
        <D.21832>:
        goto <D.21833>;
        <D.21834>:
        p.57 = p;
        D.22196 = *p.57;
        p_encoding = (guint32) D.22196;
        p.57 = p;
        p.61 = p.57 + 1;
        p = p.61;
        p.57 = p;
        read_encoded_val (p_encoding, p.57, &p);
        goto <D.21833>;
        <D.21835>:
        p.57 = p;
        D.22196 = *p.57;
        D.22216 = D.22196 + 229;
        D.22217 = D.22216 > 1;
        D.22218 = (long int) D.22217;
        D.22219 = __builtin_expect (D.22218, 0);
        if (D.22219 != 0) goto <D.22220>; else goto <D.22221>;
        <D.22220>:
        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.22221>:
        p.57 = p;
        p.61 = p.57 + 1;
        p = p.61;
        goto <D.21833>;
        <D.21836>:
        p.57 = p;
        D.22196 = *p.57;
        D.22222 = D.22196 != 27;
        D.22223 = (long int) D.22222;
        D.22224 = __builtin_expect (D.22223, 0);
        if (D.22224 != 0) goto <D.22225>; else goto <D.22226>;
        <D.22225>:
        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.22226>:
        p.57 = p;
        p.61 = p.57 + 1;
        p = p.61;
        goto <D.21833>;
        <D.21837>:
        monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "unwind.c", 882);
        <D.21833>:
        i = i + 1;
        <D.21839>:
        i.63 = (sizetype) i;
        D.22213 = cie_aug_str + i.63;
        D.22214 = *D.22213;
        if (D.22214 != 0) goto <D.21838>; else goto <D.21840>;
        <D.21840>:
        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.22210>:
      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.22180 = MEM[(guint32 *)p.57];
      pc_range = (gint32) D.22180;
      p.57 = p;
      p.59 = p.57 + 4;
      p = p.59;
      if (has_fde_augmentation != 0) goto <D.22230>; else goto <D.22231>;
      <D.22230>:
      p.57 = p;
      D.22232 = decode_uleb128 (p.57, &p);
      aug_len = (gint32) D.22232;
      fde_aug = p;
      p.57 = p;
      aug_len.67 = (sizetype) aug_len;
      p.68 = p.57 + aug_len.67;
      p = p.68;
      goto <D.22235>;
      <D.22231>:
      aug_len = 0;
      <D.22235>:
      fde_cfi = p;
      fde_len.69 = (sizetype) fde_len;
      D.22237 = fde_len.69 + 4;
      D.22238 = fde + D.22237;
      D.22239 = (int) D.22238;
      p.57 = p;
      p.70 = (int) p.57;
      fde_data_len = D.22239 - p.70;
      if (code_len != 0B) goto <D.22241>; else goto <D.22242>;
      <D.22241>:
      pc_range.71 = (unsigned int) pc_range;
      *code_len = pc_range.71;
      <D.22242>:
      if (ex_info != 0B) goto <D.22244>; else goto <D.22245>;
      <D.22244>:
      *ex_info = 0B;
      *ex_info_len = 0;
      <D.22245>:
      if (aug_len != 0) goto <D.22246>; else goto <D.22247>;
      <D.22246>:
      {
        gint32 lsda_offset;
        guint8 * lsda;

        if (aug_len == 4) goto <D.22248>; else goto <D.22249>;
        <D.22248>:
        D.22250 = mono_read32 (fde_aug);
        lsda_offset = (gint32) D.22250;
        goto <D.22251>;
        <D.22249>:
        if (aug_len == 8) goto <D.22252>; else goto <D.22253>;
        <D.22252>:
        D.22254 = MEM[(gint64 *)fde_aug];
        lsda_offset = (gint32) D.22254;
        goto <D.22255>;
        <D.22253>:
        monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "unwind.c", 929);
        <D.22255>:
        <D.22251>:
        if (lsda_offset != 0) goto <D.22256>; else goto <D.22257>;
        <D.22256>:
        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.22257>:
      }
      <D.22247>:
      D.22259 = code_align != 1;
      D.22260 = (long int) D.22259;
      D.22261 = __builtin_expect (D.22260, 0);
      if (D.22261 != 0) goto <D.22262>; else goto <D.22263>;
      <D.22262>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "unwind.c", 938, "code_align == 1");
      <D.22263>:
      D.22264 = data_align != -4;
      D.22265 = (long int) D.22264;
      D.22266 = __builtin_expect (D.22265, 0);
      if (D.22266 != 0) goto <D.22267>; else goto <D.22268>;
      <D.22267>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "unwind.c", 939, "data_align == DWARF_DATA_ALIGN");
      <D.22268>:
      D.22269 = mono_hw_reg_to_dwarf_reg (31);
      D.22270 = D.22269 != return_reg;
      D.22271 = (long int) D.22270;
      D.22272 = __builtin_expect (D.22271, 0);
      if (D.22272 != 0) goto <D.22273>; else goto <D.22274>;
      <D.22273>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "unwind.c", 940, "return_reg == DWARF_PC_REG");
      <D.22274>:
      cie_len.73 = (sizetype) cie_len;
      D.22276 = cie_len.73 + 4;
      D.22277 = cie + D.22276;
      D.22278 = (int) D.22277;
      cie_cfi.74 = (int) cie_cfi;
      D.22280 = D.22278 - cie_cfi.74;
      fde_len.69 = (sizetype) fde_len;
      D.22237 = fde_len.69 + 4;
      D.22238 = fde + D.22237;
      D.22239 = (int) D.22238;
      fde_cfi.75 = (int) fde_cfi;
      D.22282 = D.22239 - fde_cfi.75;
      buf_len = D.22280 + D.22282;
      buf_len.76 = (unsigned int) buf_len;
      buf = monoeg_malloc0 (buf_len.76);
      i = 0;
      p = cie_cfi;
      goto <D.21845>;
      <D.21844>:
      p.57 = p;
      D.22196 = *p.57;
      if (D.22196 == 0) goto <D.21843>; else goto <D.22284>;
      <D.22284>:
      p.57 = p;
      decode_cie_op (p.57, &p);
      <D.21845>:
      cie_len.73 = (sizetype) cie_len;
      D.22276 = cie_len.73 + 4;
      D.22277 = cie + D.22276;
      p.57 = p;
      if (D.22277 > p.57) goto <D.21844>; else goto <D.21843>;
      <D.21843>:
      i.63 = (sizetype) i;
      D.22285 = buf + i.63;
      p.57 = p;
      p.70 = (int) p.57;
      cie_cfi.74 = (int) cie_cfi;
      D.22286 = p.70 - cie_cfi.74;
      D.22287 = (unsigned int) D.22286;
      memcpy (D.22285, cie_cfi, D.22287);
      p.57 = p;
      p.70 = (int) p.57;
      cie_cfi.74 = (int) cie_cfi;
      D.22286 = p.70 - cie_cfi.74;
      i = D.22286 + i;
      p = fde_cfi;
      goto <D.21848>;
      <D.21847>:
      p.57 = p;
      D.22196 = *p.57;
      if (D.22196 == 0) goto <D.21846>; else goto <D.22288>;
      <D.22288>:
      p.57 = p;
      decode_cie_op (p.57, &p);
      <D.21848>:
      fde_len.69 = (sizetype) fde_len;
      D.22237 = fde_len.69 + 4;
      D.22238 = fde + D.22237;
      p.57 = p;
      if (D.22238 > p.57) goto <D.21847>; else goto <D.21846>;
      <D.21846>:
      i.63 = (sizetype) i;
      D.22285 = buf + i.63;
      p.57 = p;
      p.70 = (int) p.57;
      fde_cfi.75 = (int) fde_cfi;
      D.22289 = p.70 - fde_cfi.75;
      D.22290 = (unsigned int) D.22289;
      memcpy (D.22285, fde_cfi, D.22290);
      p.57 = p;
      p.70 = (int) p.57;
      fde_cfi.75 = (int) fde_cfi;
      D.22289 = p.70 - fde_cfi.75;
      i = D.22289 + i;
      D.22291 = i > buf_len;
      D.22292 = (long int) D.22291;
      D.22293 = __builtin_expect (D.22292, 0);
      if (D.22293 != 0) goto <D.22294>; else goto <D.22295>;
      <D.22294>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "unwind.c", 965, "i <= buf_len");
      <D.22295>:
      i.77 = (unsigned int) i;
      *out_len = i.77;
      i.78 = (unsigned int) i;
      D.22297 = monoeg_realloc (buf, i.78);
      return D.22297;
    }
  finally
    {
      p = {CLOBBER};
    }
}


read_encoded_val (guint32 encoding, guint8 * p, guint8 * * endp)
{
  unsigned int D.22302;
  int D.22303;
  gint64 D.22304;
  gint64 res;

  D.22302 = encoding & 15;
  switch (D.22302) <default: <D.21769>, case 11: <D.21768>, case 12: <D.21766>>
  <D.21766>:
  res = MEM[(gint64 *)p];
  p = p + 8;
  goto <D.21767>;
  <D.21768>:
  D.22303 = MEM[(gint32 *)p];
  res = (gint64) D.22303;
  p = p + 4;
  goto <D.21767>;
  <D.21769>:
  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "unwind.c", 717);
  <D.21767>:
  *endp = p;
  D.22304 = res;
  return D.22304;
}


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.22307;
  long int D.22308;
  long int D.22309;
  _Bool D.22312;
  long int D.22313;
  long int D.22314;
  unsigned char D.22317;
  guint8 * p.80;
  _Bool D.22321;
  long int D.22322;
  long int D.22323;
  unsigned int D.22326;
  int D.22327;
  _Bool D.22329;
  long int D.22330;
  long int D.22331;
  unsigned int D.22334;
  unsigned int p.81;
  unsigned int D.22336;
  unsigned int D.22337;
  guint8 * p.82;
  unsigned int ncall_sites.83;
  unsigned int D.22342;
  void * D.22343;
  unsigned int ncall_sites.84;
  unsigned int D.22347;
  void * D.22348;
  unsigned int D.22349;
  guint8 * p.85;
  unsigned int D.22351;
  unsigned int D.22352;
  _Bool D.22353;
  long int D.22354;
  long int D.22355;
  unsigned int tinfo.86;
  unsigned int D.22359;
  _Bool D.22360;
  long int D.22361;
  long int D.22362;
  void * * D.22367;
  unsigned int i.87;
  unsigned int D.22371;
  void * * D.22372;
  struct MonoJitExceptionInfo * D.22373;
  unsigned int D.22374;
  struct MonoJitExceptionInfo * D.22375;
  sizetype block_start_offset.88;
  void * D.22377;
  sizetype block_size.89;
  sizetype D.22379;
  guint8 * D.22380;
  sizetype landing_pad.90;
  void * D.22382;
  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.22307 = mono_magic != 1297084239;
      D.22308 = (long int) D.22307;
      D.22309 = __builtin_expect (D.22308, 0);
      if (D.22309 != 0) goto <D.22310>; else goto <D.22311>;
      <D.22310>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "unwind.c", 740, "mono_magic == 0x4d4fef4f");
      <D.22311>:
      p.79 = p;
      version = decode_uleb128 (p.79, &p);
      D.22312 = version != 1;
      D.22313 = (long int) D.22312;
      D.22314 = __builtin_expect (D.22313, 0);
      if (D.22314 != 0) goto <D.22315>; else goto <D.22316>;
      <D.22315>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "unwind.c", 742, "version == 1");
      <D.22316>:
      p.79 = p;
      D.22317 = *p.79;
      this_encoding = (int) D.22317;
      p.79 = p;
      p.80 = p.79 + 1;
      p = p.80;
      if (this_encoding == 3) goto <D.22319>; else goto <D.22320>;
      <D.22319>:
      {
        gint32 op;
        gint32 reg;
        gint32 offset;

        p.79 = p;
        D.22317 = *p.79;
        op = (gint32) D.22317;
        D.22321 = op != 146;
        D.22322 = (long int) D.22321;
        D.22323 = __builtin_expect (D.22322, 0);
        if (D.22323 != 0) goto <D.22324>; else goto <D.22325>;
        <D.22324>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "unwind.c", 750, "op == DW_OP_bregx");
        <D.22325>:
        p.79 = p;
        p.80 = p.79 + 1;
        p = p.80;
        p.79 = p;
        D.22326 = decode_uleb128 (p.79, &p);
        reg = (gint32) D.22326;
        p.79 = p;
        offset = decode_sleb128 (p.79, &p);
        D.22327 = mono_dwarf_reg_to_hw_reg (reg);
        *this_reg = D.22327;
        *this_offset = offset;
      }
      goto <D.22328>;
      <D.22320>:
      D.22329 = this_encoding != 255;
      D.22330 = (long int) D.22329;
      D.22331 = __builtin_expect (D.22330, 0);
      if (D.22331 != 0) goto <D.22332>; else goto <D.22333>;
      <D.22332>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "unwind.c", 758, "this_encoding == DW_EH_PE_omit");
      <D.22333>:
      *this_reg = -1;
      *this_offset = -1;
      <D.22328>:
      p.79 = p;
      D.22334 = decode_uleb128 (p.79, &p);
      ncall_sites = (int) D.22334;
      p.79 = p;
      p.81 = (unsigned int) p.79;
      D.22336 = p.81 + 3;
      D.22337 = D.22336 & 4294967292;
      p.82 = (guint8 *) D.22337;
      p = p.82;
      if (ex_info != 0B) goto <D.22339>; else goto <D.22340>;
      <D.22339>:
      ncall_sites.83 = (unsigned int) ncall_sites;
      D.22342 = ncall_sites.83 * 24;
      D.22343 = monoeg_malloc0 (D.22342);
      *ex_info = D.22343;
      ncall_sites.84 = (unsigned int) ncall_sites;
      *ex_info_len = ncall_sites.84;
      <D.22340>:
      if (type_info != 0B) goto <D.22345>; else goto <D.22346>;
      <D.22345>:
      ncall_sites.83 = (unsigned int) ncall_sites;
      D.22347 = ncall_sites.83 * 4;
      D.22348 = monoeg_malloc0 (D.22347);
      *type_info = D.22348;
      <D.22346>:
      i = 0;
      goto <D.21793>;
      <D.21792>:
      {
        int block_start_offset;
        int block_size;
        int landing_pad;
        guint8 * tinfo;

        p.79 = p;
        D.22349 = mono_read32 (p.79);
        block_start_offset = (int) D.22349;
        p.79 = p;
        p.85 = p.79 + 4;
        p = p.85;
        p.79 = p;
        D.22351 = mono_read32 (p.79);
        block_size = (int) D.22351;
        p.79 = p;
        p.85 = p.79 + 4;
        p = p.85;
        p.79 = p;
        D.22352 = mono_read32 (p.79);
        landing_pad = (int) D.22352;
        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.22353 = landing_pad == 0;
        D.22354 = (long int) D.22353;
        D.22355 = __builtin_expect (D.22354, 0);
        if (D.22355 != 0) goto <D.22356>; else goto <D.22357>;
        <D.22356>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "unwind.c", 786, "landing_pad");
        <D.22357>:
        tinfo.86 = (unsigned int) tinfo;
        D.22359 = tinfo.86 & 3;
        D.22360 = D.22359 != 0;
        D.22361 = (long int) D.22360;
        D.22362 = __builtin_expect (D.22361, 0);
        if (D.22362 != 0) goto <D.22363>; else goto <D.22364>;
        <D.22363>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "unwind.c", 787, "((size_t)tinfo % 4) == 0");
        <D.22364>:
        if (ex_info != 0B) goto <D.22365>; else goto <D.22366>;
        <D.22365>:
        D.22367 = *type_info;
        if (D.22367 != 0B) goto <D.22368>; else goto <D.22369>;
        <D.22368>:
        D.22367 = *type_info;
        i.87 = (unsigned int) i;
        D.22371 = i.87 * 4;
        D.22372 = D.22367 + D.22371;
        *D.22372 = tinfo;
        <D.22369>:
        D.22373 = *ex_info;
        i.87 = (unsigned int) i;
        D.22374 = i.87 * 24;
        D.22375 = D.22373 + D.22374;
        block_start_offset.88 = (sizetype) block_start_offset;
        D.22377 = code + block_start_offset.88;
        D.22375->try_start = D.22377;
        D.22373 = *ex_info;
        i.87 = (unsigned int) i;
        D.22374 = i.87 * 24;
        D.22375 = D.22373 + D.22374;
        block_start_offset.88 = (sizetype) block_start_offset;
        block_size.89 = (sizetype) block_size;
        D.22379 = block_start_offset.88 + block_size.89;
        D.22380 = code + D.22379;
        D.22375->try_end = D.22380;
        D.22373 = *ex_info;
        i.87 = (unsigned int) i;
        D.22374 = i.87 * 24;
        D.22375 = D.22373 + D.22374;
        landing_pad.90 = (sizetype) landing_pad;
        D.22382 = code + landing_pad.90;
        D.22375->handler_start = D.22382;
        <D.22366>:
      }
      i = i + 1;
      <D.21793>:
      if (i < ncall_sites) goto <D.21792>; else goto <D.21794>;
      <D.21794>:
    }
  finally
    {
      p = {CLOBBER};
    }
}


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

  p.91 = p;
  D.22384 = *p.91;
  D.22385 = (int) D.22384;
  op = D.22385 & 192;
  switch (op) <default: <D.21759>, case 0: <D.21750>, case 64: <D.21747>, case 128: <D.21749>>
  <D.21747>:
  p.91 = p;
  p.92 = p.91 + 1;
  p = p.92;
  goto <D.21748>;
  <D.21749>:
  p.91 = p;
  p.92 = p.91 + 1;
  p = p.92;
  p.91 = p;
  decode_uleb128 (p.91, &p);
  goto <D.21748>;
  <D.21750>:
  {
    int ext_op;

    p.91 = p;
    D.22384 = *p.91;
    ext_op = (int) D.22384;
    p.91 = p;
    p.92 = p.91 + 1;
    p = p.92;
    switch (ext_op) <default: <D.21758>, case 4: <D.21756>, case 12: <D.21752>, case 13: <D.21755>, case 14: <D.21754>, case 17: <D.21757>>
    <D.21752>:
    p.91 = p;
    decode_uleb128 (p.91, &p);
    p.91 = p;
    decode_uleb128 (p.91, &p);
    goto <D.21753>;
    <D.21754>:
    p.91 = p;
    decode_uleb128 (p.91, &p);
    goto <D.21753>;
    <D.21755>:
    p.91 = p;
    decode_uleb128 (p.91, &p);
    goto <D.21753>;
    <D.21756>:
    p.91 = p;
    p.93 = p.91 + 4;
    p = p.93;
    goto <D.21753>;
    <D.21757>:
    p.91 = p;
    decode_uleb128 (p.91, &p);
    p.91 = p;
    decode_uleb128 (p.91, &p);
    goto <D.21753>;
    <D.21758>:
    monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "unwind.c", 691);
    <D.21753>:
    goto <D.21748>;
  }
  <D.21759>:
  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "unwind.c", 696);
  <D.21748>:
  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.22389;
  guint8 * p.95;
  unsigned int D.22393;
  guint8 * p.96;
  sizetype aug_len.97;
  guint8 * p.98;
  struct MonoJitExceptionInfo * * D.22400;
  guint32 * D.22401;
  void * * * D.22402;
  int * D.22403;
  int * D.22404;
  unsigned int D.22405;
  unsigned int D.22406;
  unsigned int pers_encoding.99;
  _Bool D.22410;
  long int D.22411;
  long int D.22412;
  _Bool D.22415;
  long int D.22416;
  long int D.22417;
  int D.22420;
  _Bool D.22421;
  long int D.22422;
  long int D.22423;
  int p.100;
  int cie_cfi.101;
  sizetype fde_len.102;
  guint8 * D.22430;
  int D.22431;
  int fde_cfi.103;
  int D.22433;
  unsigned int D.22434;
  unsigned int cie_cfi_len.104;
  sizetype cie_cfi_len.105;
  guint8 * D.22437;
  unsigned int fde_cfi_len.106;
  unsigned int D.22439;
  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.22389 = *p.94;
      has_aug = (int) D.22389;
      p.94 = p;
      p.95 = p.94 + 1;
      p = p.95;
      if (has_aug != 0) goto <D.22391>; else goto <D.22392>;
      <D.22391>:
      p.94 = p;
      D.22393 = mono_read32 (p.94);
      aug_len = (int) D.22393;
      p.94 = p;
      p.96 = p.94 + 4;
      p = p.96;
      goto <D.22395>;
      <D.22392>:
      aug_len = 0;
      <D.22395>:
      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.22398>; else goto <D.22399>;
      <D.22398>:
      {
        guint8 * lsda;

        lsda = fde_aug;
        D.22400 = &res->ex_info;
        D.22401 = &res->ex_info_len;
        D.22402 = &res->type_info;
        D.22403 = &res->this_reg;
        D.22404 = &res->this_offset;
        decode_lsda (lsda, code, D.22400, D.22401, D.22402, D.22403, D.22404);
      }
      <D.22399>:
      p = cie;
      p.94 = p;
      D.22405 = decode_uleb128 (p.94, &p);
      code_align = (gint32) D.22405;
      p.94 = p;
      data_align = decode_sleb128 (p.94, &p);
      p.94 = p;
      D.22406 = decode_uleb128 (p.94, &p);
      return_reg = (gint32) D.22406;
      p.94 = p;
      D.22389 = *p.94;
      pers_encoding = (gint32) D.22389;
      p.94 = p;
      p.95 = p.94 + 1;
      p = p.95;
      if (pers_encoding != 255) goto <D.22407>; else goto <D.22408>;
      <D.22407>:
      pers_encoding.99 = (unsigned int) pers_encoding;
      p.94 = p;
      read_encoded_val (pers_encoding.99, p.94, &p);
      <D.22408>:
      cie_cfi = p;
      D.22410 = code_align != 1;
      D.22411 = (long int) D.22410;
      D.22412 = __builtin_expect (D.22411, 0);
      if (D.22412 != 0) goto <D.22413>; else goto <D.22414>;
      <D.22413>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "unwind.c", 1028, "code_align == 1");
      <D.22414>:
      D.22415 = data_align != -4;
      D.22416 = (long int) D.22415;
      D.22417 = __builtin_expect (D.22416, 0);
      if (D.22417 != 0) goto <D.22418>; else goto <D.22419>;
      <D.22418>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "unwind.c", 1029, "data_align == DWARF_DATA_ALIGN");
      <D.22419>:
      D.22420 = mono_hw_reg_to_dwarf_reg (31);
      D.22421 = D.22420 != return_reg;
      D.22422 = (long int) D.22421;
      D.22423 = __builtin_expect (D.22422, 0);
      if (D.22423 != 0) goto <D.22424>; else goto <D.22425>;
      <D.22424>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "unwind.c", 1030, "return_reg == DWARF_PC_REG");
      <D.22425>:
      p = cie_cfi;
      <D.21871>:
      p.94 = p;
      D.22389 = *p.94;
      if (D.22389 == 0) goto <D.21870>; else goto <D.22426>;
      <D.22426>:
      p.94 = p;
      decode_cie_op (p.94, &p);
      goto <D.21871>;
      <D.21870>:
      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.22430 = fde + fde_len.102;
      D.22431 = (int) D.22430;
      fde_cfi.103 = (int) fde_cfi;
      fde_cfi_len = D.22431 - fde_cfi.103;
      D.22433 = cie_cfi_len + fde_cfi_len;
      D.22434 = (unsigned int) D.22433;
      buf = monoeg_malloc0 (D.22434);
      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.22437 = buf + cie_cfi_len.105;
      fde_cfi_len.106 = (unsigned int) fde_cfi_len;
      memcpy (D.22437, fde_cfi, fde_cfi_len.106);
      D.22433 = cie_cfi_len + fde_cfi_len;
      D.22439 = (unsigned int) D.22433;
      res->unw_info_len = D.22439;
      res->unw_info = buf;
    }
  finally
    {
      p = {CLOBBER};
    }
}


mono_unwind_get_cie_program ()
{
  struct GSList * D.22440;

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