dlmalloc (size_t bytes)
{
  unsigned int D.7785;
  int D.7787;
  unsigned int D.7788;
  unsigned int D.7789;
  int D.7790;
  unsigned int iftmp.0;
  unsigned int D.7796;
  unsigned int D.7798;
  int idx.1;
  unsigned int D.7800;
  unsigned int D.7803;
  _Bool D.7804;
  unsigned int D.7805;
  unsigned int D.7806;
  unsigned int D.7809;
  unsigned int D.7810;
  unsigned int D.7811;
  char * D.7813;
  _Bool D.7814;
  long int D.7815;
  long int D.7816;
  unsigned int D.7820;
  unsigned int D.7821;
  struct malloc_chunk * D.7822;
  unsigned int D.7823;
  unsigned int D.7824;
  unsigned int D.7825;
  unsigned int D.7830;
  unsigned int D.7831;
  unsigned int D.7832;
  unsigned int D.7833;
  unsigned int D.7834;
  unsigned int D.7835;
  int K.2;
  unsigned int D.7837;
  unsigned int K.3;
  unsigned int D.7839;
  unsigned int K.4;
  unsigned int D.7841;
  unsigned int K.5;
  unsigned int K.6;
  unsigned int D.7844;
  int i.7;
  unsigned int D.7848;
  unsigned int D.7849;
  unsigned int D.7850;
  _Bool D.7852;
  long int D.7853;
  long int D.7854;
  unsigned int D.7858;
  unsigned int D.7861;
  struct malloc_chunk * D.7862;
  unsigned int D.7863;
  unsigned int D.7864;
  unsigned int D.7866;
  unsigned int D.7867;
  struct malloc_chunk * D.7868;
  unsigned int D.7871;
  int I.8;
  unsigned int D.7873;
  unsigned int D.7874;
  unsigned int D.7877;
  struct malloc_chunk * D.7879;
  _Bool D.7880;
  long int D.7881;
  long int D.7882;
  unsigned int D.7886;
  struct malloc_chunk * D.7901;
  unsigned int D.7902;
  struct malloc_chunk * D.7903;
  unsigned int D.7905;
  struct malloc_chunk * D.7906;
  unsigned int D.7907;
  unsigned int D.7908;
  unsigned int D.7909;
  unsigned int D.7912;
  struct malloc_chunk * D.7913;
  unsigned int D.7914;
  void * D.7917;
  void postaction = <<< error >>>;

  D.7785 = mparams.page_size;
  if (D.7785 != 0) goto <D.7781>; else goto <D.7786>;
  <D.7786>:
  D.7787 = init_mparams ();
  if (D.7787 == 0) goto <D.7781>; else goto <D.7782>;
  <D.7781>:
  D.7788 = _gm_.mflags;
  D.7789 = D.7788 & 2;
  if (D.7789 == 0) goto <D.7783>; else goto <D.7782>;
  <D.7782>:
  D.7790 = pthread_mutex_lock (&_gm_.mutex);
  if (D.7790 == 0) goto <D.7783>; else goto <D.7784>;
  <D.7783>:
  {
    void * mem;
    size_t nb;

    if (bytes <= 244) goto <D.7791>; else goto <D.7792>;
    <D.7791>:
    {
      bindex_t idx;
      binmap_t smallbits;

      if (bytes > 10) goto <D.7794>; else goto <D.7795>;
      <D.7794>:
      D.7796 = bytes + 11;
      iftmp.0 = D.7796 & 4294967288;
      goto <D.7797>;
      <D.7795>:
      iftmp.0 = 16;
      <D.7797>:
      nb = iftmp.0;
      idx = nb >> 3;
      D.7798 = _gm_.smallmap;
      idx.1 = (int) idx;
      smallbits = D.7798 >> idx.1;
      D.7800 = smallbits & 3;
      if (D.7800 != 0) goto <D.7801>; else goto <D.7802>;
      <D.7801>:
      {
        struct malloc_chunk * b;
        struct malloc_chunk * p;

        D.7803 = smallbits & 1;
        D.7804 = D.7803 == 0;
        D.7805 = (unsigned int) D.7804;
        idx = D.7805 + idx;
        D.7806 = idx << 1;
        b = &_gm_.smallbins[D.7806];
        p = b->fd;
        {
          struct malloc_chunk * F;

          F = p->fd;
          if (b == F) goto <D.7807>; else goto <D.7808>;
          <D.7807>:
          D.7798 = _gm_.smallmap;
          idx.1 = (int) idx;
          D.7809 = 1 << idx.1;
          D.7810 = ~D.7809;
          D.7811 = D.7798 & D.7810;
          _gm_.smallmap = D.7811;
          goto <D.7812>;
          <D.7808>:
          D.7813 = _gm_.least_addr;
          D.7814 = D.7813 <= F;
          D.7815 = (long int) D.7814;
          D.7816 = __builtin_expect (D.7815, 1);
          if (D.7816 != 0) goto <D.7817>; else goto <D.7818>;
          <D.7817>:
          b->fd = F;
          F->bk = b;
          goto <D.7819>;
          <D.7818>:
          abort ();
          <D.7819>:
          <D.7812>:
        }
        D.7820 = idx << 3;
        D.7821 = D.7820 | 3;
        p->head = D.7821;
        D.7820 = idx << 3;
        D.7822 = p + D.7820;
        D.7820 = idx << 3;
        D.7822 = p + D.7820;
        D.7823 = D.7822->head;
        D.7824 = D.7823 | 1;
        D.7822->head = D.7824;
        mem = p + 8;
        goto postaction;
      }
      <D.7802>:
      D.7825 = _gm_.dvsize;
      if (D.7825 < nb) goto <D.7826>; else goto <D.7827>;
      <D.7826>:
      if (smallbits != 0) goto <D.7828>; else goto <D.7829>;
      <D.7828>:
      {
        struct malloc_chunk * b;
        struct malloc_chunk * p;
        struct malloc_chunk * r;
        size_t rsize;
        bindex_t i;
        binmap_t leftbits;
        binmap_t leastbit;

        idx.1 = (int) idx;
        D.7830 = smallbits << idx.1;
        idx.1 = (int) idx;
        D.7809 = 1 << idx.1;
        D.7831 = D.7809 << 1;
        idx.1 = (int) idx;
        D.7809 = 1 << idx.1;
        D.7831 = D.7809 << 1;
        D.7832 = -D.7831;
        D.7833 = D.7831 | D.7832;
        leftbits = D.7830 & D.7833;
        D.7834 = -leftbits;
        leastbit = D.7834 & leftbits;
        {
          unsigned int Y;
          unsigned int K;
          unsigned int N;

          Y = leastbit + 4294967295;
          D.7835 = Y >> 12;
          K = D.7835 & 16;
          N = K;
          K.2 = (int) K;
          Y = Y >> K.2;
          D.7837 = Y >> 5;
          K = D.7837 & 8;
          K.3 = K;
          N = K.3 + N;
          K.2 = (int) K;
          Y = Y >> K.2;
          D.7839 = Y >> 2;
          K = D.7839 & 4;
          K.4 = K;
          N = K.4 + N;
          K.2 = (int) K;
          Y = Y >> K.2;
          D.7841 = Y >> 1;
          K = D.7841 & 2;
          K.5 = K;
          N = K.5 + N;
          K.2 = (int) K;
          Y = Y >> K.2;
          D.7841 = Y >> 1;
          K = D.7841 & 1;
          K.6 = K;
          N = K.6 + N;
          K.2 = (int) K;
          Y = Y >> K.2;
          i = N + Y;
        }
        D.7844 = i << 1;
        b = &_gm_.smallbins[D.7844];
        p = b->fd;
        {
          struct malloc_chunk * F;

          F = p->fd;
          if (b == F) goto <D.7845>; else goto <D.7846>;
          <D.7845>:
          D.7798 = _gm_.smallmap;
          i.7 = (int) i;
          D.7848 = 1 << i.7;
          D.7849 = ~D.7848;
          D.7850 = D.7798 & D.7849;
          _gm_.smallmap = D.7850;
          goto <D.7851>;
          <D.7846>:
          D.7813 = _gm_.least_addr;
          D.7852 = D.7813 <= F;
          D.7853 = (long int) D.7852;
          D.7854 = __builtin_expect (D.7853, 1);
          if (D.7854 != 0) goto <D.7855>; else goto <D.7856>;
          <D.7855>:
          b->fd = F;
          F->bk = b;
          goto <D.7857>;
          <D.7856>:
          abort ();
          <D.7857>:
          <D.7851>:
        }
        D.7858 = i << 3;
        rsize = D.7858 - nb;
        if (0 != 0) goto <D.7859>; else goto <D.7860>;
        <D.7859>:
        D.7858 = i << 3;
        D.7861 = D.7858 | 3;
        p->head = D.7861;
        D.7858 = i << 3;
        D.7862 = p + D.7858;
        D.7858 = i << 3;
        D.7862 = p + D.7858;
        D.7863 = D.7862->head;
        D.7864 = D.7863 | 1;
        D.7862->head = D.7864;
        goto <D.7865>;
        <D.7860>:
        D.7866 = nb | 3;
        p->head = D.7866;
        r = p + nb;
        D.7867 = rsize | 1;
        r->head = D.7867;
        D.7868 = r + rsize;
        D.7868->prev_foot = rsize;
        {
          size_t DVS;

          DVS = _gm_.dvsize;
          if (DVS != 0) goto <D.7869>; else goto <D.7870>;
          <D.7869>:
          {
            struct malloc_chunk * DV;

            DV = _gm_.dv;
            {
              bindex_t I;
              struct malloc_chunk * B;
              struct malloc_chunk * F;

              I = DVS >> 3;
              D.7871 = I << 1;
              B = &_gm_.smallbins[D.7871];
              F = B;
              D.7798 = _gm_.smallmap;
              I.8 = (int) I;
              D.7873 = 1 << I.8;
              D.7874 = D.7798 & D.7873;
              if (D.7874 == 0) goto <D.7875>; else goto <D.7876>;
              <D.7875>:
              D.7798 = _gm_.smallmap;
              I.8 = (int) I;
              D.7873 = 1 << I.8;
              D.7877 = D.7798 | D.7873;
              _gm_.smallmap = D.7877;
              goto <D.7878>;
              <D.7876>:
              D.7879 = B->fd;
              D.7813 = _gm_.least_addr;
              D.7880 = D.7879 >= D.7813;
              D.7881 = (long int) D.7880;
              D.7882 = __builtin_expect (D.7881, 1);
              if (D.7882 != 0) goto <D.7883>; else goto <D.7884>;
              <D.7883>:
              F = B->fd;
              goto <D.7885>;
              <D.7884>:
              abort ();
              <D.7885>:
              <D.7878>:
              B->fd = DV;
              F->bk = DV;
              DV->fd = F;
              DV->bk = B;
            }
          }
          <D.7870>:
          _gm_.dvsize = rsize;
          _gm_.dv = r;
        }
        <D.7865>:
        mem = p + 8;
        goto postaction;
      }
      <D.7829>:
      D.7886 = _gm_.treemap;
      if (D.7886 != 0) goto <D.7887>; else goto <D.7888>;
      <D.7887>:
      mem = tmalloc_small (&_gm_, nb);
      if (mem != 0B) goto postaction; else goto <D.7889>;
      <D.7889>:
      <D.7888>:
      <D.7827>:
    }
    goto <D.7890>;
    <D.7792>:
    if (bytes > 4294967231) goto <D.7891>; else goto <D.7892>;
    <D.7891>:
    nb = 4294967295;
    goto <D.7893>;
    <D.7892>:
    D.7796 = bytes + 11;
    nb = D.7796 & 4294967288;
    D.7886 = _gm_.treemap;
    if (D.7886 != 0) goto <D.7894>; else goto <D.7895>;
    <D.7894>:
    mem = tmalloc_large (&_gm_, nb);
    if (mem != 0B) goto postaction; else goto <D.7896>;
    <D.7896>:
    <D.7895>:
    <D.7893>:
    <D.7890>:
    D.7825 = _gm_.dvsize;
    if (D.7825 >= nb) goto <D.7897>; else goto <D.7898>;
    <D.7897>:
    {
      size_t rsize;
      struct malloc_chunk * p;

      D.7825 = _gm_.dvsize;
      rsize = D.7825 - nb;
      p = _gm_.dv;
      if (rsize > 15) goto <D.7899>; else goto <D.7900>;
      <D.7899>:
      {
        struct malloc_chunk * r;

        D.7901 = p + nb;
        _gm_.dv = D.7901;
        r = _gm_.dv;
        _gm_.dvsize = rsize;
        D.7902 = rsize | 1;
        r->head = D.7902;
        D.7903 = r + rsize;
        D.7903->prev_foot = rsize;
        D.7866 = nb | 3;
        p->head = D.7866;
      }
      goto <D.7904>;
      <D.7900>:
      {
        size_t dvs;

        dvs = _gm_.dvsize;
        _gm_.dvsize = 0;
        _gm_.dv = 0B;
        D.7905 = dvs | 3;
        p->head = D.7905;
        D.7906 = p + dvs;
        D.7906 = p + dvs;
        D.7907 = D.7906->head;
        D.7908 = D.7907 | 1;
        D.7906->head = D.7908;
      }
      <D.7904>:
      mem = p + 8;
      goto postaction;
    }
    <D.7898>:
    D.7909 = _gm_.topsize;
    if (D.7909 > nb) goto <D.7910>; else goto <D.7911>;
    <D.7910>:
    {
      size_t rsize;
      struct malloc_chunk * p;
      struct malloc_chunk * r;

      D.7909 = _gm_.topsize;
      D.7912 = D.7909 - nb;
      _gm_.topsize = D.7912;
      rsize = _gm_.topsize;
      p = _gm_.top;
      D.7913 = p + nb;
      _gm_.top = D.7913;
      r = _gm_.top;
      D.7914 = rsize | 1;
      r->head = D.7914;
      D.7866 = nb | 3;
      p->head = D.7866;
      mem = p + 8;
      goto postaction;
    }
    <D.7911>:
    mem = sys_alloc (&_gm_, nb);
    postaction:
    D.7788 = _gm_.mflags;
    D.7789 = D.7788 & 2;
    if (D.7789 != 0) goto <D.7915>; else goto <D.7916>;
    <D.7915>:
    pthread_mutex_unlock (&_gm_.mutex);
    <D.7916>:
    D.7917 = mem;
    return D.7917;
  }
  <D.7784>:
  D.7917 = 0B;
  return D.7917;
}


init_mparams ()
{
  unsigned int D.7919;
  unsigned int D.7922;
  unsigned int D.7925;
  unsigned int D.7928;
  unsigned int D.7929;
  unsigned int D.7930;
  unsigned int D.7932;
  unsigned int D.7933;
  int D.7934;

  D.7919 = mparams.page_size;
  if (D.7919 == 0) goto <D.7920>; else goto <D.7921>;
  <D.7920>:
  {
    size_t s;

    mparams.mmap_threshold = 262144;
    mparams.trim_threshold = 2097152;
    mparams.default_mflags = 7;
    s = 1482184792;
    pthread_mutex_lock (&magic_init_mutex);
    D.7922 = mparams.magic;
    if (D.7922 == 0) goto <D.7923>; else goto <D.7924>;
    <D.7923>:
    mparams.magic = s;
    pthread_mutex_init (&_gm_.mutex, 0B);
    D.7925 = mparams.default_mflags;
    _gm_.mflags = D.7925;
    <D.7924>:
    pthread_mutex_unlock (&magic_init_mutex);
    mparams.page_size = 4096;
    mparams.granularity = 65536;
    D.7928 = mparams.granularity;
    D.7928 = mparams.granularity;
    D.7929 = D.7928 + 4294967295;
    D.7930 = D.7928 & D.7929;
    if (D.7930 != 0) goto <D.7926>; else goto <D.7931>;
    <D.7931>:
    D.7919 = mparams.page_size;
    D.7919 = mparams.page_size;
    D.7932 = D.7919 + 4294967295;
    D.7933 = D.7919 & D.7932;
    if (D.7933 != 0) goto <D.7926>; else goto <D.7927>;
    <D.7926>:
    abort ();
    <D.7927>:
  }
  <D.7921>:
  D.7934 = 0;
  return D.7934;
}


tmalloc_small (struct malloc_state * m, size_t nb)
{
  unsigned int D.7936;
  unsigned int D.7937;
  unsigned int D.7938;
  int K.9;
  unsigned int D.7940;
  unsigned int K.10;
  unsigned int D.7942;
  unsigned int K.11;
  unsigned int D.7944;
  unsigned int K.12;
  unsigned int K.13;
  unsigned int D.7947;
  unsigned int D.7948;
  struct malloc_tree_chunk * iftmp.14;
  struct malloc_tree_chunk * D.7952;
  char * D.7956;
  _Bool D.7957;
  long int D.7958;
  long int D.7959;
  _Bool D.7962;
  long int D.7963;
  long int D.7964;
  struct malloc_tree_chunk * D.7967;
  _Bool D.7970;
  long int D.7971;
  long int D.7972;
  struct malloc_tree_chunk * D.7980;
  _Bool D.7982;
  long int D.7983;
  long int D.7984;
  unsigned int D.7990;
  struct malloc_tree_chunk * D.7991;
  int D.7996;
  unsigned int D.7997;
  unsigned int D.7998;
  unsigned int D.7999;
  _Bool D.8001;
  long int D.8002;
  long int D.8003;
  struct malloc_tree_chunk * D.8006;
  _Bool D.8013;
  long int D.8014;
  long int D.8015;
  _Bool D.8020;
  long int D.8021;
  long int D.8022;
  _Bool D.8028;
  long int D.8029;
  long int D.8030;
  unsigned int D.8037;
  unsigned int D.8038;
  struct malloc_chunk * D.8039;
  unsigned int D.8040;
  unsigned int D.8041;
  unsigned int D.8043;
  unsigned int D.8044;
  struct malloc_chunk * D.8045;
  unsigned int D.8048;
  unsigned int D.8049;
  int I.15;
  unsigned int D.8051;
  unsigned int D.8052;
  unsigned int D.8055;
  struct malloc_chunk * D.8057;
  _Bool D.8058;
  long int D.8059;
  long int D.8060;
  void * D.8064;
  struct malloc_tree_chunk * t;
  struct malloc_tree_chunk * v;
  size_t rsize;
  bindex_t i;
  binmap_t leastbit;

  D.7936 = m->treemap;
  D.7936 = m->treemap;
  D.7937 = -D.7936;
  leastbit = D.7936 & D.7937;
  {
    unsigned int Y;
    unsigned int K;
    unsigned int N;

    Y = leastbit + 4294967295;
    D.7938 = Y >> 12;
    K = D.7938 & 16;
    N = K;
    K.9 = (int) K;
    Y = Y >> K.9;
    D.7940 = Y >> 5;
    K = D.7940 & 8;
    K.10 = K;
    N = K.10 + N;
    K.9 = (int) K;
    Y = Y >> K.9;
    D.7942 = Y >> 2;
    K = D.7942 & 4;
    K.11 = K;
    N = K.11 + N;
    K.9 = (int) K;
    Y = Y >> K.9;
    D.7944 = Y >> 1;
    K = D.7944 & 2;
    K.12 = K;
    N = K.12 + N;
    K.9 = (int) K;
    Y = Y >> K.9;
    D.7944 = Y >> 1;
    K = D.7944 & 1;
    K.13 = K;
    N = K.13 + N;
    K.9 = (int) K;
    Y = Y >> K.9;
    i = N + Y;
  }
  t = m->treebins[i];
  v = t;
  D.7947 = t->head;
  D.7948 = D.7947 & 4294967292;
  rsize = D.7948 - nb;
  goto <D.7639>;
  <D.7638>:
  {
    size_t trem;

    D.7947 = t->head;
    D.7948 = D.7947 & 4294967292;
    trem = D.7948 - nb;
    if (trem < rsize) goto <D.7949>; else goto <D.7950>;
    <D.7949>:
    rsize = trem;
    v = t;
    <D.7950>:
  }
  <D.7639>:
  D.7952 = t->child[0];
  if (D.7952 != 0B) goto <D.7953>; else goto <D.7954>;
  <D.7953>:
  iftmp.14 = t->child[0];
  goto <D.7955>;
  <D.7954>:
  iftmp.14 = t->child[1];
  <D.7955>:
  t = iftmp.14;
  if (t != 0B) goto <D.7638>; else goto <D.7640>;
  <D.7640>:
  D.7956 = m->least_addr;
  D.7957 = D.7956 <= v;
  D.7958 = (long int) D.7957;
  D.7959 = __builtin_expect (D.7958, 1);
  if (D.7959 != 0) goto <D.7960>; else goto <D.7961>;
  <D.7960>:
  {
    struct malloc_chunk * r;

    r = v + nb;
    D.7962 = v < r;
    D.7963 = (long int) D.7962;
    D.7964 = __builtin_expect (D.7963, 1);
    if (D.7964 != 0) goto <D.7965>; else goto <D.7966>;
    <D.7965>:
    {
      struct malloc_tree_chunk * XP;
      struct malloc_tree_chunk * R;

      XP = v->parent;
      D.7967 = v->bk;
      if (D.7967 != v) goto <D.7968>; else goto <D.7969>;
      <D.7968>:
      {
        struct malloc_tree_chunk * F;

        F = v->fd;
        R = v->bk;
        D.7956 = m->least_addr;
        D.7970 = D.7956 <= F;
        D.7971 = (long int) D.7970;
        D.7972 = __builtin_expect (D.7971, 1);
        if (D.7972 != 0) goto <D.7973>; else goto <D.7974>;
        <D.7973>:
        F->bk = R;
        R->fd = F;
        goto <D.7975>;
        <D.7974>:
        abort ();
        <D.7975>:
      }
      goto <D.7976>;
      <D.7969>:
      {
        struct malloc_tree_chunk * * RP;

        RP = &v->child[1];
        R = *RP;
        if (R != 0B) goto <D.7977>; else goto <D.7979>;
        <D.7979>:
        RP = &v->child[0];
        R = *RP;
        if (R != 0B) goto <D.7977>; else goto <D.7978>;
        <D.7977>:
        {
          struct malloc_tree_chunk * * CP;

          goto <D.7648>;
          <D.7647>:
          RP = CP;
          R = *RP;
          <D.7648>:
          CP = &R->child[1];
          D.7980 = *CP;
          if (D.7980 != 0B) goto <D.7647>; else goto <D.7981>;
          <D.7981>:
          CP = &R->child[0];
          D.7980 = *CP;
          if (D.7980 != 0B) goto <D.7647>; else goto <D.7649>;
          <D.7649>:
          D.7956 = m->least_addr;
          D.7982 = D.7956 <= RP;
          D.7983 = (long int) D.7982;
          D.7984 = __builtin_expect (D.7983, 1);
          if (D.7984 != 0) goto <D.7985>; else goto <D.7986>;
          <D.7985>:
          *RP = 0B;
          goto <D.7987>;
          <D.7986>:
          abort ();
          <D.7987>:
        }
        <D.7978>:
      }
      <D.7976>:
      if (XP != 0B) goto <D.7988>; else goto <D.7989>;
      <D.7988>:
      {
        struct malloc_tree_chunk * * H;

        D.7990 = v->index;
        H = &m->treebins[D.7990];
        D.7991 = *H;
        if (D.7991 == v) goto <D.7992>; else goto <D.7993>;
        <D.7992>:
        *H = R;
        D.7991 = *H;
        if (D.7991 == 0B) goto <D.7994>; else goto <D.7995>;
        <D.7994>:
        D.7936 = m->treemap;
        D.7990 = v->index;
        D.7996 = (int) D.7990;
        D.7997 = 1 << D.7996;
        D.7998 = ~D.7997;
        D.7999 = D.7936 & D.7998;
        m->treemap = D.7999;
        <D.7995>:
        goto <D.8000>;
        <D.7993>:
        D.7956 = m->least_addr;
        D.8001 = D.7956 <= XP;
        D.8002 = (long int) D.8001;
        D.8003 = __builtin_expect (D.8002, 1);
        if (D.8003 != 0) goto <D.8004>; else goto <D.8005>;
        <D.8004>:
        D.8006 = XP->child[0];
        if (D.8006 == v) goto <D.8007>; else goto <D.8008>;
        <D.8007>:
        XP->child[0] = R;
        goto <D.8009>;
        <D.8008>:
        XP->child[1] = R;
        <D.8009>:
        goto <D.8010>;
        <D.8005>:
        abort ();
        <D.8010>:
        <D.8000>:
        if (R != 0B) goto <D.8011>; else goto <D.8012>;
        <D.8011>:
        D.7956 = m->least_addr;
        D.8013 = D.7956 <= R;
        D.8014 = (long int) D.8013;
        D.8015 = __builtin_expect (D.8014, 1);
        if (D.8015 != 0) goto <D.8016>; else goto <D.8017>;
        <D.8016>:
        {
          struct malloc_tree_chunk * C0;
          struct malloc_tree_chunk * C1;

          R->parent = XP;
          C0 = v->child[0];
          if (C0 != 0B) goto <D.8018>; else goto <D.8019>;
          <D.8018>:
          D.7956 = m->least_addr;
          D.8020 = D.7956 <= C0;
          D.8021 = (long int) D.8020;
          D.8022 = __builtin_expect (D.8021, 1);
          if (D.8022 != 0) goto <D.8023>; else goto <D.8024>;
          <D.8023>:
          R->child[0] = C0;
          C0->parent = R;
          goto <D.8025>;
          <D.8024>:
          abort ();
          <D.8025>:
          <D.8019>:
          C1 = v->child[1];
          if (C1 != 0B) goto <D.8026>; else goto <D.8027>;
          <D.8026>:
          D.7956 = m->least_addr;
          D.8028 = D.7956 <= C1;
          D.8029 = (long int) D.8028;
          D.8030 = __builtin_expect (D.8029, 1);
          if (D.8030 != 0) goto <D.8031>; else goto <D.8032>;
          <D.8031>:
          R->child[1] = C1;
          C1->parent = R;
          goto <D.8033>;
          <D.8032>:
          abort ();
          <D.8033>:
          <D.8027>:
        }
        goto <D.8034>;
        <D.8017>:
        abort ();
        <D.8034>:
        <D.8012>:
      }
      <D.7989>:
    }
    if (rsize <= 15) goto <D.8035>; else goto <D.8036>;
    <D.8035>:
    D.8037 = rsize + nb;
    D.8038 = D.8037 | 3;
    v->head = D.8038;
    D.8037 = rsize + nb;
    D.8039 = v + D.8037;
    D.8037 = rsize + nb;
    D.8039 = v + D.8037;
    D.8040 = D.8039->head;
    D.8041 = D.8040 | 1;
    D.8039->head = D.8041;
    goto <D.8042>;
    <D.8036>:
    D.8043 = nb | 3;
    v->head = D.8043;
    D.8044 = rsize | 1;
    r->head = D.8044;
    D.8045 = r + rsize;
    D.8045->prev_foot = rsize;
    {
      size_t DVS;

      DVS = m->dvsize;
      if (DVS != 0) goto <D.8046>; else goto <D.8047>;
      <D.8046>:
      {
        struct malloc_chunk * DV;

        DV = m->dv;
        {
          bindex_t I;
          struct malloc_chunk * B;
          struct malloc_chunk * F;

          I = DVS >> 3;
          D.8048 = I << 1;
          B = &m->smallbins[D.8048];
          F = B;
          D.8049 = m->smallmap;
          I.15 = (int) I;
          D.8051 = 1 << I.15;
          D.8052 = D.8049 & D.8051;
          if (D.8052 == 0) goto <D.8053>; else goto <D.8054>;
          <D.8053>:
          D.8049 = m->smallmap;
          I.15 = (int) I;
          D.8051 = 1 << I.15;
          D.8055 = D.8049 | D.8051;
          m->smallmap = D.8055;
          goto <D.8056>;
          <D.8054>:
          D.8057 = B->fd;
          D.7956 = m->least_addr;
          D.8058 = D.8057 >= D.7956;
          D.8059 = (long int) D.8058;
          D.8060 = __builtin_expect (D.8059, 1);
          if (D.8060 != 0) goto <D.8061>; else goto <D.8062>;
          <D.8061>:
          F = B->fd;
          goto <D.8063>;
          <D.8062>:
          abort ();
          <D.8063>:
          <D.8056>:
          B->fd = DV;
          F->bk = DV;
          DV->fd = F;
          DV->bk = B;
        }
      }
      <D.8047>:
      m->dvsize = rsize;
      m->dv = r;
    }
    <D.8042>:
    D.8064 = v + 8;
    return D.8064;
    <D.7966>:
  }
  <D.7961>:
  abort ();
  D.8064 = 0B;
  return D.8064;
}


tmalloc_large (struct malloc_state * m, size_t nb)
{
  unsigned int D.8072;
  unsigned int D.8073;
  int N.16;
  unsigned int D.8075;
  unsigned int D.8076;
  int K.17;
  unsigned int D.8078;
  unsigned int D.8079;
  unsigned int K.18;
  unsigned int D.8081;
  unsigned int D.8082;
  unsigned int D.8083;
  unsigned int D.8084;
  int D.8085;
  unsigned int D.8086;
  unsigned int D.8087;
  int iftmp.19;
  unsigned int D.8093;
  unsigned int D.8094;
  unsigned int D.8096;
  unsigned int D.8097;
  unsigned int D.8101;
  _Bool D.8102;
  _Bool D.8103;
  _Bool D.8104;
  _Bool D.8109;
  _Bool D.8110;
  _Bool D.8111;
  int idx.20;
  unsigned int D.8115;
  unsigned int D.8116;
  unsigned int D.8117;
  unsigned int D.8118;
  unsigned int D.8119;
  unsigned int D.8122;
  unsigned int D.8123;
  int K.21;
  unsigned int D.8125;
  unsigned int K.22;
  unsigned int D.8127;
  unsigned int K.23;
  unsigned int D.8129;
  unsigned int K.24;
  unsigned int K.25;
  struct malloc_tree_chunk * iftmp.26;
  struct malloc_tree_chunk * D.8135;
  unsigned int D.8141;
  unsigned int D.8142;
  char * D.8145;
  _Bool D.8146;
  long int D.8147;
  long int D.8148;
  _Bool D.8151;
  long int D.8152;
  long int D.8153;
  struct malloc_tree_chunk * D.8156;
  _Bool D.8159;
  long int D.8160;
  long int D.8161;
  struct malloc_tree_chunk * D.8169;
  _Bool D.8171;
  long int D.8172;
  long int D.8173;
  unsigned int D.8179;
  struct malloc_tree_chunk * D.8180;
  int D.8185;
  unsigned int D.8186;
  unsigned int D.8187;
  unsigned int D.8188;
  _Bool D.8190;
  long int D.8191;
  long int D.8192;
  struct malloc_tree_chunk * D.8195;
  _Bool D.8202;
  long int D.8203;
  long int D.8204;
  _Bool D.8209;
  long int D.8210;
  long int D.8211;
  _Bool D.8217;
  long int D.8218;
  long int D.8219;
  unsigned int D.8226;
  unsigned int D.8227;
  struct malloc_chunk * D.8228;
  unsigned int D.8229;
  unsigned int D.8230;
  unsigned int D.8232;
  unsigned int D.8233;
  struct malloc_chunk * D.8234;
  unsigned int D.8235;
  unsigned int D.8238;
  unsigned int D.8239;
  int I.27;
  unsigned int D.8241;
  unsigned int D.8242;
  unsigned int D.8245;
  struct malloc_chunk * D.8247;
  _Bool D.8248;
  long int D.8249;
  long int D.8250;
  unsigned int D.8261;
  unsigned int D.8262;
  int N.28;
  unsigned int D.8264;
  unsigned int D.8265;
  int K.29;
  unsigned int D.8267;
  unsigned int D.8268;
  unsigned int K.30;
  unsigned int D.8270;
  unsigned int D.8271;
  unsigned int D.8272;
  unsigned int D.8273;
  int D.8274;
  unsigned int D.8275;
  unsigned int D.8276;
  struct malloc_tree_chunk * D.8277;
  int I.31;
  unsigned int D.8279;
  unsigned int D.8280;
  unsigned int D.8283;
  struct malloc_tree_chunk * D.8284;
  int iftmp.32;
  unsigned int D.8289;
  unsigned int D.8290;
  unsigned int D.8292;
  unsigned int D.8293;
  unsigned int D.8296;
  struct malloc_tree_chunk * D.8297;
  _Bool D.8301;
  long int D.8302;
  long int D.8303;
  _Bool D.8308;
  long int D.8309;
  long int D.8310;
  _Bool D.8312;
  long int D.8313;
  long int D.8314;
  struct malloc_tree_chunk * D.8316;
  void * D.8317;
  struct malloc_tree_chunk * v;
  size_t rsize;
  struct malloc_tree_chunk * t;
  bindex_t idx;

  v = 0B;
  rsize = -nb;
  {
    size_t X;

    X = nb >> 8;
    if (X == 0) goto <D.8066>; else goto <D.8067>;
    <D.8066>:
    idx = 0;
    goto <D.8068>;
    <D.8067>:
    if (X > 65535) goto <D.8069>; else goto <D.8070>;
    <D.8069>:
    idx = 31;
    goto <D.8071>;
    <D.8070>:
    {
      unsigned int Y;
      unsigned int N;
      unsigned int K;

      Y = X;
      D.8072 = Y + 4294967040;
      D.8073 = D.8072 >> 16;
      N = D.8073 & 8;
      N.16 = (int) N;
      Y = Y << N.16;
      D.8075 = Y + 4294963200;
      D.8076 = D.8075 >> 16;
      K = D.8076 & 4;
      N = N + K;
      K.17 = (int) K;
      Y = Y << K.17;
      D.8078 = Y + 4294950912;
      D.8079 = D.8078 >> 16;
      K = D.8079 & 2;
      K.18 = K;
      N = K.18 + N;
      K.17 = (int) K;
      Y = Y << K.17;
      D.8081 = Y >> 15;
      D.8082 = D.8081 - N;
      K = D.8082 + 14;
      D.8083 = K << 1;
      D.8084 = K + 7;
      D.8085 = (int) D.8084;
      D.8086 = nb >> D.8085;
      D.8087 = D.8086 & 1;
      idx = D.8083 + D.8087;
    }
    <D.8071>:
    <D.8068>:
  }
  t = m->treebins[idx];
  if (t != 0B) goto <D.8088>; else goto <D.8089>;
  <D.8088>:
  {
    size_t sizebits;
    struct malloc_tree_chunk * rst;

    if (idx != 31) goto <D.8091>; else goto <D.8092>;
    <D.8091>:
    D.8093 = idx >> 1;
    D.8094 = 25 - D.8093;
    iftmp.19 = (int) D.8094;
    goto <D.8095>;
    <D.8092>:
    iftmp.19 = 0;
    <D.8095>:
    sizebits = nb << iftmp.19;
    rst = 0B;
    <D.7586>:
    {
      struct malloc_tree_chunk * rt;
      size_t trem;

      D.8096 = t->head;
      D.8097 = D.8096 & 4294967292;
      trem = D.8097 - nb;
      if (trem < rsize) goto <D.8098>; else goto <D.8099>;
      <D.8098>:
      v = t;
      rsize = trem;
      if (rsize == 0) goto <D.7585>; else goto <D.8100>;
      <D.8100>:
      <D.8099>:
      rt = t->child[1];
      D.8101 = sizebits >> 31;
      t = t->child[D.8101];
      D.8102 = rt != 0B;
      D.8103 = rt != t;
      D.8104 = D.8102 & D.8103;
      if (D.8104 != 0) goto <D.8105>; else goto <D.8106>;
      <D.8105>:
      rst = rt;
      <D.8106>:
      if (t == 0B) goto <D.8107>; else goto <D.8108>;
      <D.8107>:
      t = rst;
      goto <D.7585>;
      <D.8108>:
      sizebits = sizebits << 1;
    }
    goto <D.7586>;
    <D.7585>:
  }
  <D.8089>:
  D.8109 = t == 0B;
  D.8110 = v == 0B;
  D.8111 = D.8109 & D.8110;
  if (D.8111 != 0) goto <D.8112>; else goto <D.8113>;
  <D.8112>:
  {
    binmap_t leftbits;

    idx.20 = (int) idx;
    D.8115 = 1 << idx.20;
    D.8116 = D.8115 << 1;
    idx.20 = (int) idx;
    D.8115 = 1 << idx.20;
    D.8116 = D.8115 << 1;
    D.8117 = -D.8116;
    D.8118 = D.8116 | D.8117;
    D.8119 = m->treemap;
    leftbits = D.8118 & D.8119;
    if (leftbits != 0) goto <D.8120>; else goto <D.8121>;
    <D.8120>:
    {
      bindex_t i;
      binmap_t leastbit;

      D.8122 = -leftbits;
      leastbit = D.8122 & leftbits;
      {
        unsigned int Y;
        unsigned int K;
        unsigned int N;

        Y = leastbit + 4294967295;
        D.8123 = Y >> 12;
        K = D.8123 & 16;
        N = K;
        K.21 = (int) K;
        Y = Y >> K.21;
        D.8125 = Y >> 5;
        K = D.8125 & 8;
        K.22 = K;
        N = K.22 + N;
        K.21 = (int) K;
        Y = Y >> K.21;
        D.8127 = Y >> 2;
        K = D.8127 & 4;
        K.23 = K;
        N = K.23 + N;
        K.21 = (int) K;
        Y = Y >> K.21;
        D.8129 = Y >> 1;
        K = D.8129 & 2;
        K.24 = K;
        N = K.24 + N;
        K.21 = (int) K;
        Y = Y >> K.21;
        D.8129 = Y >> 1;
        K = D.8129 & 1;
        K.25 = K;
        N = K.25 + N;
        K.21 = (int) K;
        Y = Y >> K.21;
        i = N + Y;
      }
      t = m->treebins[i];
    }
    <D.8121>:
  }
  <D.8113>:
  goto <D.7595>;
  <D.7594>:
  {
    size_t trem;

    D.8096 = t->head;
    D.8097 = D.8096 & 4294967292;
    trem = D.8097 - nb;
    if (trem < rsize) goto <D.8132>; else goto <D.8133>;
    <D.8132>:
    rsize = trem;
    v = t;
    <D.8133>:
    D.8135 = t->child[0];
    if (D.8135 != 0B) goto <D.8136>; else goto <D.8137>;
    <D.8136>:
    iftmp.26 = t->child[0];
    goto <D.8138>;
    <D.8137>:
    iftmp.26 = t->child[1];
    <D.8138>:
    t = iftmp.26;
  }
  <D.7595>:
  if (t != 0B) goto <D.7594>; else goto <D.7596>;
  <D.7596>:
  if (v != 0B) goto <D.8139>; else goto <D.8140>;
  <D.8139>:
  D.8141 = m->dvsize;
  D.8142 = D.8141 - nb;
  if (D.8142 > rsize) goto <D.8143>; else goto <D.8144>;
  <D.8143>:
  D.8145 = m->least_addr;
  D.8146 = D.8145 <= v;
  D.8147 = (long int) D.8146;
  D.8148 = __builtin_expect (D.8147, 1);
  if (D.8148 != 0) goto <D.8149>; else goto <D.8150>;
  <D.8149>:
  {
    struct malloc_chunk * r;

    r = v + nb;
    D.8151 = v < r;
    D.8152 = (long int) D.8151;
    D.8153 = __builtin_expect (D.8152, 1);
    if (D.8153 != 0) goto <D.8154>; else goto <D.8155>;
    <D.8154>:
    {
      struct malloc_tree_chunk * XP;
      struct malloc_tree_chunk * R;

      XP = v->parent;
      D.8156 = v->bk;
      if (D.8156 != v) goto <D.8157>; else goto <D.8158>;
      <D.8157>:
      {
        struct malloc_tree_chunk * F;

        F = v->fd;
        R = v->bk;
        D.8145 = m->least_addr;
        D.8159 = D.8145 <= F;
        D.8160 = (long int) D.8159;
        D.8161 = __builtin_expect (D.8160, 1);
        if (D.8161 != 0) goto <D.8162>; else goto <D.8163>;
        <D.8162>:
        F->bk = R;
        R->fd = F;
        goto <D.8164>;
        <D.8163>:
        abort ();
        <D.8164>:
      }
      goto <D.8165>;
      <D.8158>:
      {
        struct malloc_tree_chunk * * RP;

        RP = &v->child[1];
        R = *RP;
        if (R != 0B) goto <D.8166>; else goto <D.8168>;
        <D.8168>:
        RP = &v->child[0];
        R = *RP;
        if (R != 0B) goto <D.8166>; else goto <D.8167>;
        <D.8166>:
        {
          struct malloc_tree_chunk * * CP;

          goto <D.7604>;
          <D.7603>:
          RP = CP;
          R = *RP;
          <D.7604>:
          CP = &R->child[1];
          D.8169 = *CP;
          if (D.8169 != 0B) goto <D.7603>; else goto <D.8170>;
          <D.8170>:
          CP = &R->child[0];
          D.8169 = *CP;
          if (D.8169 != 0B) goto <D.7603>; else goto <D.7605>;
          <D.7605>:
          D.8145 = m->least_addr;
          D.8171 = D.8145 <= RP;
          D.8172 = (long int) D.8171;
          D.8173 = __builtin_expect (D.8172, 1);
          if (D.8173 != 0) goto <D.8174>; else goto <D.8175>;
          <D.8174>:
          *RP = 0B;
          goto <D.8176>;
          <D.8175>:
          abort ();
          <D.8176>:
        }
        <D.8167>:
      }
      <D.8165>:
      if (XP != 0B) goto <D.8177>; else goto <D.8178>;
      <D.8177>:
      {
        struct malloc_tree_chunk * * H;

        D.8179 = v->index;
        H = &m->treebins[D.8179];
        D.8180 = *H;
        if (D.8180 == v) goto <D.8181>; else goto <D.8182>;
        <D.8181>:
        *H = R;
        D.8180 = *H;
        if (D.8180 == 0B) goto <D.8183>; else goto <D.8184>;
        <D.8183>:
        D.8119 = m->treemap;
        D.8179 = v->index;
        D.8185 = (int) D.8179;
        D.8186 = 1 << D.8185;
        D.8187 = ~D.8186;
        D.8188 = D.8119 & D.8187;
        m->treemap = D.8188;
        <D.8184>:
        goto <D.8189>;
        <D.8182>:
        D.8145 = m->least_addr;
        D.8190 = D.8145 <= XP;
        D.8191 = (long int) D.8190;
        D.8192 = __builtin_expect (D.8191, 1);
        if (D.8192 != 0) goto <D.8193>; else goto <D.8194>;
        <D.8193>:
        D.8195 = XP->child[0];
        if (D.8195 == v) goto <D.8196>; else goto <D.8197>;
        <D.8196>:
        XP->child[0] = R;
        goto <D.8198>;
        <D.8197>:
        XP->child[1] = R;
        <D.8198>:
        goto <D.8199>;
        <D.8194>:
        abort ();
        <D.8199>:
        <D.8189>:
        if (R != 0B) goto <D.8200>; else goto <D.8201>;
        <D.8200>:
        D.8145 = m->least_addr;
        D.8202 = D.8145 <= R;
        D.8203 = (long int) D.8202;
        D.8204 = __builtin_expect (D.8203, 1);
        if (D.8204 != 0) goto <D.8205>; else goto <D.8206>;
        <D.8205>:
        {
          struct malloc_tree_chunk * C0;
          struct malloc_tree_chunk * C1;

          R->parent = XP;
          C0 = v->child[0];
          if (C0 != 0B) goto <D.8207>; else goto <D.8208>;
          <D.8207>:
          D.8145 = m->least_addr;
          D.8209 = D.8145 <= C0;
          D.8210 = (long int) D.8209;
          D.8211 = __builtin_expect (D.8210, 1);
          if (D.8211 != 0) goto <D.8212>; else goto <D.8213>;
          <D.8212>:
          R->child[0] = C0;
          C0->parent = R;
          goto <D.8214>;
          <D.8213>:
          abort ();
          <D.8214>:
          <D.8208>:
          C1 = v->child[1];
          if (C1 != 0B) goto <D.8215>; else goto <D.8216>;
          <D.8215>:
          D.8145 = m->least_addr;
          D.8217 = D.8145 <= C1;
          D.8218 = (long int) D.8217;
          D.8219 = __builtin_expect (D.8218, 1);
          if (D.8219 != 0) goto <D.8220>; else goto <D.8221>;
          <D.8220>:
          R->child[1] = C1;
          C1->parent = R;
          goto <D.8222>;
          <D.8221>:
          abort ();
          <D.8222>:
          <D.8216>:
        }
        goto <D.8223>;
        <D.8206>:
        abort ();
        <D.8223>:
        <D.8201>:
      }
      <D.8178>:
    }
    if (rsize <= 15) goto <D.8224>; else goto <D.8225>;
    <D.8224>:
    D.8226 = rsize + nb;
    D.8227 = D.8226 | 3;
    v->head = D.8227;
    D.8226 = rsize + nb;
    D.8228 = v + D.8226;
    D.8226 = rsize + nb;
    D.8228 = v + D.8226;
    D.8229 = D.8228->head;
    D.8230 = D.8229 | 1;
    D.8228->head = D.8230;
    goto <D.8231>;
    <D.8225>:
    D.8232 = nb | 3;
    v->head = D.8232;
    D.8233 = rsize | 1;
    r->head = D.8233;
    D.8234 = r + rsize;
    D.8234->prev_foot = rsize;
    D.8235 = rsize >> 3;
    if (D.8235 <= 31) goto <D.8236>; else goto <D.8237>;
    <D.8236>:
    {
      bindex_t I;
      struct malloc_chunk * B;
      struct malloc_chunk * F;

      I = rsize >> 3;
      D.8238 = I << 1;
      B = &m->smallbins[D.8238];
      F = B;
      D.8239 = m->smallmap;
      I.27 = (int) I;
      D.8241 = 1 << I.27;
      D.8242 = D.8239 & D.8241;
      if (D.8242 == 0) goto <D.8243>; else goto <D.8244>;
      <D.8243>:
      D.8239 = m->smallmap;
      I.27 = (int) I;
      D.8241 = 1 << I.27;
      D.8245 = D.8239 | D.8241;
      m->smallmap = D.8245;
      goto <D.8246>;
      <D.8244>:
      D.8247 = B->fd;
      D.8145 = m->least_addr;
      D.8248 = D.8247 >= D.8145;
      D.8249 = (long int) D.8248;
      D.8250 = __builtin_expect (D.8249, 1);
      if (D.8250 != 0) goto <D.8251>; else goto <D.8252>;
      <D.8251>:
      F = B->fd;
      goto <D.8253>;
      <D.8252>:
      abort ();
      <D.8253>:
      <D.8246>:
      B->fd = r;
      F->bk = r;
      r->fd = F;
      r->bk = B;
    }
    goto <D.8254>;
    <D.8237>:
    {
      struct malloc_tree_chunk * TP;

      TP = r;
      {
        struct malloc_tree_chunk * * H;
        bindex_t I;

        {
          size_t X;

          X = rsize >> 8;
          if (X == 0) goto <D.8255>; else goto <D.8256>;
          <D.8255>:
          I = 0;
          goto <D.8257>;
          <D.8256>:
          if (X > 65535) goto <D.8258>; else goto <D.8259>;
          <D.8258>:
          I = 31;
          goto <D.8260>;
          <D.8259>:
          {
            unsigned int Y;
            unsigned int N;
            unsigned int K;

            Y = X;
            D.8261 = Y + 4294967040;
            D.8262 = D.8261 >> 16;
            N = D.8262 & 8;
            N.28 = (int) N;
            Y = Y << N.28;
            D.8264 = Y + 4294963200;
            D.8265 = D.8264 >> 16;
            K = D.8265 & 4;
            N = N + K;
            K.29 = (int) K;
            Y = Y << K.29;
            D.8267 = Y + 4294950912;
            D.8268 = D.8267 >> 16;
            K = D.8268 & 2;
            K.30 = K;
            N = K.30 + N;
            K.29 = (int) K;
            Y = Y << K.29;
            D.8270 = Y >> 15;
            D.8271 = D.8270 - N;
            K = D.8271 + 14;
            D.8272 = K << 1;
            D.8273 = K + 7;
            D.8274 = (int) D.8273;
            D.8275 = rsize >> D.8274;
            D.8276 = D.8275 & 1;
            I = D.8272 + D.8276;
          }
          <D.8260>:
          <D.8257>:
        }
        H = &m->treebins[I];
        TP->index = I;
        TP->child[1] = 0B;
        D.8277 = TP->child[1];
        TP->child[0] = D.8277;
        D.8119 = m->treemap;
        I.31 = (int) I;
        D.8279 = 1 << I.31;
        D.8280 = D.8119 & D.8279;
        if (D.8280 == 0) goto <D.8281>; else goto <D.8282>;
        <D.8281>:
        D.8119 = m->treemap;
        I.31 = (int) I;
        D.8279 = 1 << I.31;
        D.8283 = D.8119 | D.8279;
        m->treemap = D.8283;
        *H = TP;
        TP->parent = H;
        TP->bk = TP;
        D.8284 = TP->bk;
        TP->fd = D.8284;
        goto <D.8285>;
        <D.8282>:
        {
          struct malloc_tree_chunk * T;
          size_t K;

          T = *H;
          if (I != 31) goto <D.8287>; else goto <D.8288>;
          <D.8287>:
          D.8289 = I >> 1;
          D.8290 = 25 - D.8289;
          iftmp.32 = (int) D.8290;
          goto <D.8291>;
          <D.8288>:
          iftmp.32 = 0;
          <D.8291>:
          K = rsize << iftmp.32;
          <D.7624>:
          D.8292 = T->head;
          D.8293 = D.8292 & 4294967292;
          if (D.8293 != rsize) goto <D.8294>; else goto <D.8295>;
          <D.8294>:
          {
            struct malloc_tree_chunk * * C;

            D.8296 = K >> 31;
            C = &T->child[D.8296];
            K = K << 1;
            D.8297 = *C;
            if (D.8297 != 0B) goto <D.8298>; else goto <D.8299>;
            <D.8298>:
            T = *C;
            goto <D.8300>;
            <D.8299>:
            D.8145 = m->least_addr;
            D.8301 = D.8145 <= C;
            D.8302 = (long int) D.8301;
            D.8303 = __builtin_expect (D.8302, 1);
            if (D.8303 != 0) goto <D.8304>; else goto <D.8305>;
            <D.8304>:
            *C = TP;
            TP->parent = T;
            TP->bk = TP;
            D.8284 = TP->bk;
            TP->fd = D.8284;
            goto <D.7622>;
            <D.8305>:
            abort ();
            <D.8300>:
          }
          goto <D.8306>;
          <D.8295>:
          {
            struct malloc_tree_chunk * F;

            F = T->fd;
            D.8145 = m->least_addr;
            D.8308 = D.8145 <= T;
            D.8309 = (long int) D.8308;
            D.8310 = __builtin_expect (D.8309, 1);
            if (D.8310 != 0) goto <D.8311>; else goto <D.8307>;
            <D.8311>:
            D.8145 = m->least_addr;
            D.8312 = D.8145 <= F;
            D.8313 = (long int) D.8312;
            D.8314 = __builtin_expect (D.8313, 1);
            if (D.8314 != 0) goto <D.8315>; else goto <D.8307>;
            <D.8315>:
            F->bk = TP;
            D.8316 = F->bk;
            T->fd = D.8316;
            TP->fd = F;
            TP->bk = T;
            TP->parent = 0B;
            goto <D.7622>;
            <D.8307>:
            abort ();
          }
          <D.8306>:
          goto <D.7624>;
          <D.7622>:
        }
        <D.8285>:
      }
    }
    <D.8254>:
    <D.8231>:
    D.8317 = v + 8;
    return D.8317;
    <D.8155>:
  }
  <D.8150>:
  abort ();
  <D.8144>:
  <D.8140>:
  D.8317 = 0B;
  return D.8317;
}


sys_alloc (struct malloc_state * m, size_t nb)
{
  unsigned int D.8319;
  unsigned int D.8320;
  unsigned int D.8323;
  void * D.8328;
  struct malloc_segment * iftmp.33;
  struct malloc_chunk * D.8332;
  unsigned int D.8340;
  unsigned int D.8341;
  unsigned int D.8342;
  unsigned int D.8343;
  unsigned int D.8344;
  unsigned int D.8345;
  unsigned int base.34;
  unsigned int D.8347;
  unsigned int D.8350;
  unsigned int D.8351;
  unsigned int D.8352;
  unsigned int D.8353;
  unsigned int D.8359;
  unsigned int D.8360;
  unsigned int D.8361;
  unsigned int D.8362;
  char * D.8365;
  unsigned int D.8366;
  char * D.8367;
  unsigned int D.8376;
  unsigned int D.8379;
  unsigned int D.8380;
  unsigned int D.8381;
  unsigned int D.8390;
  unsigned int D.8393;
  _Bool D.8402;
  _Bool D.8403;
  _Bool D.8404;
  int end.35;
  int br.36;
  int D.8411;
  unsigned int D.8412;
  unsigned int D.8417;
  unsigned int D.8418;
  unsigned int D.8419;
  char * D.8424;
  unsigned int D.8425;
  unsigned int D.8428;
  struct malloc_chunk * D.8430;
  unsigned int D.8431;
  sizetype D.8432;
  sizetype D.8433;
  char * D.8434;
  int D.8435;
  int mn.37;
  int D.8437;
  unsigned int D.8438;
  unsigned int D.8439;
  char * D.8442;
  unsigned int D.8443;
  char * D.8444;
  unsigned int D.8448;
  unsigned int D.8449;
  unsigned int D.8451;
  unsigned int D.8455;
  unsigned int D.8456;
  unsigned int D.8466;
  struct malloc_chunk * D.8467;
  unsigned int D.8468;
  unsigned int D.8469;
  int * D.8470;
  char * tbase;
  size_t tsize;
  flag_t mmap_flag;

  tbase = 4294967295B;
  tsize = 0;
  mmap_flag = 0;
  init_mparams ();
  D.8319 = m->mflags;
  D.8320 = D.8319 & 1;
  if (D.8320 != 0) goto <D.8321>; else goto <D.8322>;
  <D.8321>:
  D.8323 = mparams.mmap_threshold;
  if (D.8323 <= nb) goto <D.8324>; else goto <D.8325>;
  <D.8324>:
  {
    void * mem;

    mem = mmap_alloc (m, nb);
    if (mem != 0B) goto <D.8326>; else goto <D.8327>;
    <D.8326>:
    D.8328 = mem;
    return D.8328;
    <D.8327>:
  }
  <D.8325>:
  <D.8322>:
  if (0 != 0) goto <D.8329>; else goto <D.8330>;
  <D.8329>:
  {
    char * br;
    struct malloc_segment * ss;
    size_t asize;

    br = 4294967295B;
    D.8332 = m->top;
    if (D.8332 != 0B) goto <D.8333>; else goto <D.8334>;
    <D.8333>:
    D.8332 = m->top;
    iftmp.33 = segment_holding (m, D.8332);
    goto <D.8335>;
    <D.8334>:
    iftmp.33 = 0B;
    <D.8335>:
    ss = iftmp.33;
    asize = 0;
    if (ss == 0B) goto <D.8336>; else goto <D.8337>;
    <D.8336>:
    {
      char * base;

      base = 4294967295B;
      if (base != 4294967295B) goto <D.8338>; else goto <D.8339>;
      <D.8338>:
      D.8340 = mparams.granularity;
      D.8341 = D.8340 + nb;
      D.8342 = D.8341 + 41;
      D.8340 = mparams.granularity;
      D.8343 = -D.8340;
      asize = D.8342 & D.8343;
      D.8344 = mparams.page_size;
      D.8345 = D.8344 + 4294967295;
      base.34 = (unsigned int) base;
      D.8347 = D.8345 & base.34;
      if (D.8347 != 0) goto <D.8348>; else goto <D.8349>;
      <D.8348>:
      D.8344 = mparams.page_size;
      base.34 = (unsigned int) base;
      D.8350 = D.8344 + base.34;
      D.8344 = mparams.page_size;
      D.8351 = -D.8344;
      D.8352 = D.8350 & D.8351;
      base.34 = (unsigned int) base;
      D.8353 = D.8352 - base.34;
      asize = D.8353 + asize;
      <D.8349>:
      if (asize <= 2147483646) goto <D.8354>; else goto <D.8355>;
      <D.8354>:
      br = 4294967295B;
      if (br == base) goto <D.8356>; else goto <D.8357>;
      <D.8356>:
      tbase = base;
      tsize = asize;
      <D.8357>:
      <D.8355>:
      <D.8339>:
    }
    goto <D.8358>;
    <D.8337>:
    D.8359 = m->topsize;
    D.8360 = nb - D.8359;
    D.8340 = mparams.granularity;
    D.8361 = D.8360 + D.8340;
    D.8362 = D.8361 + 41;
    D.8340 = mparams.granularity;
    D.8343 = -D.8340;
    asize = D.8362 & D.8343;
    if (asize <= 2147483646) goto <D.8363>; else goto <D.8364>;
    <D.8363>:
    br = 4294967295B;
    D.8365 = ss->base;
    D.8366 = ss->size;
    D.8367 = D.8365 + D.8366;
    if (br == D.8367) goto <D.8368>; else goto <D.8369>;
    <D.8368>:
    tbase = br;
    tsize = asize;
    <D.8369>:
    <D.8364>:
    <D.8358>:
    if (tbase == 4294967295B) goto <D.8370>; else goto <D.8371>;
    <D.8370>:
    if (br != 4294967295B) goto <D.8372>; else goto <D.8373>;
    <D.8372>:
    if (asize <= 2147483646) goto <D.8374>; else goto <D.8375>;
    <D.8374>:
    D.8376 = nb + 41;
    if (D.8376 > asize) goto <D.8377>; else goto <D.8378>;
    <D.8377>:
    {
      size_t esize;

      D.8379 = nb - asize;
      D.8340 = mparams.granularity;
      D.8380 = D.8379 + D.8340;
      D.8381 = D.8380 + 41;
      D.8340 = mparams.granularity;
      D.8343 = -D.8340;
      esize = D.8381 & D.8343;
      if (esize <= 2147483646) goto <D.8382>; else goto <D.8383>;
      <D.8382>:
      {
        char * end;

        end = 4294967295B;
        if (end != 4294967295B) goto <D.8384>; else goto <D.8385>;
        <D.8384>:
        asize = asize + esize;
        goto <D.8386>;
        <D.8385>:
        br = 4294967295B;
        <D.8386>:
      }
      <D.8383>:
    }
    <D.8378>:
    <D.8375>:
    <D.8373>:
    if (br != 4294967295B) goto <D.8387>; else goto <D.8388>;
    <D.8387>:
    tbase = br;
    tsize = asize;
    goto <D.8389>;
    <D.8388>:
    D.8319 = m->mflags;
    D.8390 = D.8319 | 4;
    m->mflags = D.8390;
    <D.8389>:
    <D.8371>:
  }
  <D.8330>:
  if (tbase == 4294967295B) goto <D.8391>; else goto <D.8392>;
  <D.8391>:
  {
    size_t req;
    size_t rsize;

    req = nb + 41;
    D.8340 = mparams.granularity;
    D.8393 = D.8340 + req;
    D.8340 = mparams.granularity;
    D.8343 = -D.8340;
    rsize = D.8393 & D.8343;
    if (rsize > nb) goto <D.8394>; else goto <D.8395>;
    <D.8394>:
    {
      char * mp;

      mp = mmap (0B, rsize, 7, 34, -1, 0);
      if (mp != 4294967295B) goto <D.8396>; else goto <D.8397>;
      <D.8396>:
      tbase = mp;
      tsize = rsize;
      mmap_flag = 1;
      <D.8397>:
    }
    <D.8395>:
  }
  <D.8392>:
  if (0 != 0) goto <D.8398>; else goto <D.8399>;
  <D.8398>:
  {
    size_t asize;

    D.8340 = mparams.granularity;
    D.8341 = D.8340 + nb;
    D.8342 = D.8341 + 41;
    D.8340 = mparams.granularity;
    D.8343 = -D.8340;
    asize = D.8342 & D.8343;
    if (asize <= 2147483646) goto <D.8400>; else goto <D.8401>;
    <D.8400>:
    {
      char * br;
      char * end;

      br = 4294967295B;
      end = 4294967295B;
      br = 4294967295B;
      end = 4294967295B;
      D.8402 = br != 4294967295B;
      D.8403 = end != 4294967295B;
      D.8404 = D.8402 & D.8403;
      if (D.8404 != 0) goto <D.8405>; else goto <D.8406>;
      <D.8405>:
      if (br < end) goto <D.8407>; else goto <D.8408>;
      <D.8407>:
      {
        size_t ssize;

        end.35 = (int) end;
        br.36 = (int) br;
        D.8411 = end.35 - br.36;
        ssize = (size_t) D.8411;
        D.8412 = nb + 40;
        if (D.8412 < ssize) goto <D.8413>; else goto <D.8414>;
        <D.8413>:
        tbase = br;
        tsize = ssize;
        <D.8414>:
      }
      <D.8408>:
      <D.8406>:
    }
    <D.8401>:
  }
  <D.8399>:
  if (tbase != 4294967295B) goto <D.8415>; else goto <D.8416>;
  <D.8415>:
  D.8417 = m->footprint;
  D.8418 = D.8417 + tsize;
  m->footprint = D.8418;
  D.8417 = m->footprint;
  D.8419 = m->max_footprint;
  if (D.8417 > D.8419) goto <D.8420>; else goto <D.8421>;
  <D.8420>:
  D.8417 = m->footprint;
  m->max_footprint = D.8417;
  <D.8421>:
  D.8332 = m->top;
  if (D.8332 == 0B) goto <D.8422>; else goto <D.8423>;
  <D.8422>:
  m->least_addr = tbase;
  D.8424 = m->least_addr;
  m->seg.base = D.8424;
  m->seg.size = tsize;
  m->seg.sflags = mmap_flag;
  D.8425 = mparams.magic;
  m->magic = D.8425;
  init_bins (m);
  if (m == &_gm_) goto <D.8426>; else goto <D.8427>;
  <D.8426>:
  D.8428 = tsize + 4294967256;
  init_top (m, tbase, D.8428);
  goto <D.8429>;
  <D.8427>:
  {
    struct malloc_chunk * mn;

    D.8430 = m + 4294967288;
    D.8431 = D.8430->head;
    D.8432 = D.8431 & 4294967292;
    D.8433 = D.8432 + 4294967288;
    mn = m + D.8433;
    D.8434 = tbase + tsize;
    D.8435 = (int) D.8434;
    mn.37 = (int) mn;
    D.8437 = D.8435 - mn.37;
    D.8438 = (unsigned int) D.8437;
    D.8439 = D.8438 + 4294967256;
    init_top (m, mn, D.8439);
  }
  <D.8429>:
  goto <D.8440>;
  <D.8423>:
  {
    struct malloc_segment * sp;

    sp = &m->seg;
    goto <D.7510>;
    <D.7509>:
    sp = sp->next;
    <D.7510>:
    if (sp != 0B) goto <D.8441>; else goto <D.7511>;
    <D.8441>:
    D.8442 = sp->base;
    D.8443 = sp->size;
    D.8444 = D.8442 + D.8443;
    if (D.8444 != tbase) goto <D.7509>; else goto <D.7511>;
    <D.7511>:
    if (sp != 0B) goto <D.8447>; else goto <D.8445>;
    <D.8447>:
    D.8448 = sp->sflags;
    D.8449 = D.8448 & 8;
    if (D.8449 == 0) goto <D.8450>; else goto <D.8445>;
    <D.8450>:
    D.8448 = sp->sflags;
    D.8451 = D.8448 & 1;
    if (D.8451 == mmap_flag) goto <D.8452>; else goto <D.8445>;
    <D.8452>:
    D.8332 = m->top;
    D.8442 = sp->base;
    if (D.8332 >= D.8442) goto <D.8453>; else goto <D.8445>;
    <D.8453>:
    D.8332 = m->top;
    D.8442 = sp->base;
    D.8443 = sp->size;
    D.8444 = D.8442 + D.8443;
    if (D.8332 < D.8444) goto <D.8454>; else goto <D.8445>;
    <D.8454>:
    D.8443 = sp->size;
    D.8455 = D.8443 + tsize;
    sp->size = D.8455;
    D.8332 = m->top;
    D.8359 = m->topsize;
    D.8456 = D.8359 + tsize;
    init_top (m, D.8332, D.8456);
    goto <D.8446>;
    <D.8445>:
    D.8424 = m->least_addr;
    if (D.8424 > tbase) goto <D.8457>; else goto <D.8458>;
    <D.8457>:
    m->least_addr = tbase;
    <D.8458>:
    sp = &m->seg;
    goto <D.7513>;
    <D.7512>:
    sp = sp->next;
    <D.7513>:
    if (sp != 0B) goto <D.8459>; else goto <D.7514>;
    <D.8459>:
    D.8442 = sp->base;
    D.8434 = tbase + tsize;
    if (D.8442 != D.8434) goto <D.7512>; else goto <D.7514>;
    <D.7514>:
    if (sp != 0B) goto <D.8461>; else goto <D.8460>;
    <D.8461>:
    D.8448 = sp->sflags;
    D.8449 = D.8448 & 8;
    if (D.8449 == 0) goto <D.8462>; else goto <D.8460>;
    <D.8462>:
    D.8448 = sp->sflags;
    D.8451 = D.8448 & 1;
    if (D.8451 == mmap_flag) goto <D.8463>; else goto <D.8460>;
    <D.8463>:
    {
      char * oldbase;

      oldbase = sp->base;
      sp->base = tbase;
      D.8443 = sp->size;
      D.8455 = D.8443 + tsize;
      sp->size = D.8455;
      D.8328 = prepend_alloc (m, tbase, oldbase, nb);
      return D.8328;
    }
    <D.8460>:
    add_segment (m, tbase, tsize, mmap_flag);
    <D.8446>:
  }
  <D.8440>:
  D.8359 = m->topsize;
  if (D.8359 > nb) goto <D.8464>; else goto <D.8465>;
  <D.8464>:
  {
    size_t rsize;
    struct malloc_chunk * p;
    struct malloc_chunk * r;

    D.8359 = m->topsize;
    D.8466 = D.8359 - nb;
    m->topsize = D.8466;
    rsize = m->topsize;
    p = m->top;
    D.8467 = p + nb;
    m->top = D.8467;
    r = m->top;
    D.8468 = rsize | 1;
    r->head = D.8468;
    D.8469 = nb | 3;
    p->head = D.8469;
    D.8328 = p + 8;
    return D.8328;
  }
  <D.8465>:
  <D.8416>:
  D.8470 = __errno_location ();
  *D.8470 = 12;
  D.8328 = 0B;
  return D.8328;
}


mmap_alloc (struct malloc_state * m, size_t nb)
{
  unsigned int D.8472;
  unsigned int D.8473;
  unsigned int D.8474;
  unsigned int D.8475;
  unsigned int iftmp.38;
  void * D.8481;
  unsigned int D.8482;
  unsigned int D.8483;
  unsigned int D.8486;
  unsigned int D.8488;
  unsigned int D.8489;
  unsigned int D.8490;
  struct malloc_chunk * D.8491;
  sizetype D.8492;
  struct malloc_chunk * D.8493;
  char * D.8494;
  unsigned int D.8497;
  unsigned int D.8498;
  unsigned int D.8499;
  void * D.8502;
  size_t mmsize;

  D.8472 = mparams.granularity;
  D.8473 = D.8472 + nb;
  D.8474 = D.8473 + 31;
  D.8472 = mparams.granularity;
  D.8475 = -D.8472;
  mmsize = D.8474 & D.8475;
  if (mmsize > nb) goto <D.8476>; else goto <D.8477>;
  <D.8476>:
  {
    char * mm;

    mm = mmap (0B, mmsize, 7, 34, -1, 0);
    if (mm != 4294967295B) goto <D.8478>; else goto <D.8479>;
    <D.8478>:
    {
      size_t offset;
      size_t psize;
      struct malloc_chunk * p;

      D.8481 = mm + 8;
      D.8482 = (unsigned int) D.8481;
      D.8483 = D.8482 & 7;
      if (D.8483 != 0) goto <D.8484>; else goto <D.8485>;
      <D.8484>:
      D.8481 = mm + 8;
      D.8482 = (unsigned int) D.8481;
      D.8486 = -D.8482;
      iftmp.38 = D.8486 & 7;
      goto <D.8487>;
      <D.8485>:
      iftmp.38 = 0;
      <D.8487>:
      offset = iftmp.38;
      D.8488 = mmsize - offset;
      psize = D.8488 + 4294967280;
      p = mm + offset;
      D.8489 = offset | 1;
      p->prev_foot = D.8489;
      D.8490 = psize | 2;
      p->head = D.8490;
      D.8491 = p + psize;
      D.8491->head = 7;
      D.8492 = psize + 4;
      D.8493 = p + D.8492;
      D.8493->head = 0;
      D.8494 = m->least_addr;
      if (D.8494 > mm) goto <D.8495>; else goto <D.8496>;
      <D.8495>:
      m->least_addr = mm;
      <D.8496>:
      D.8497 = m->footprint;
      D.8498 = D.8497 + mmsize;
      m->footprint = D.8498;
      D.8497 = m->footprint;
      D.8499 = m->max_footprint;
      if (D.8497 > D.8499) goto <D.8500>; else goto <D.8501>;
      <D.8500>:
      D.8497 = m->footprint;
      m->max_footprint = D.8497;
      <D.8501>:
      D.8502 = p + 8;
      return D.8502;
    }
    <D.8479>:
  }
  <D.8477>:
  D.8502 = 0B;
  return D.8502;
}


init_bins (struct malloc_state * m)
{
  unsigned int D.8504;
  struct malloc_chunk * D.8505;
  bindex_t i;

  i = 0;
  goto <D.7398>;
  <D.7397>:
  {
    struct malloc_chunk * bin;

    D.8504 = i << 1;
    bin = &m->smallbins[D.8504];
    bin->bk = bin;
    D.8505 = bin->bk;
    bin->fd = D.8505;
  }
  i = i + 1;
  <D.7398>:
  if (i <= 31) goto <D.7397>; else goto <D.7399>;
  <D.7399>:
}


init_top (struct malloc_state * m, struct malloc_chunk * p, size_t psize)
{
  unsigned int iftmp.39;
  void * D.8507;
  unsigned int D.8508;
  unsigned int D.8509;
  unsigned int D.8512;
  unsigned int D.8514;
  struct malloc_chunk * D.8515;
  unsigned int D.8516;
  size_t offset;

  D.8507 = p + 8;
  D.8508 = (unsigned int) D.8507;
  D.8509 = D.8508 & 7;
  if (D.8509 != 0) goto <D.8510>; else goto <D.8511>;
  <D.8510>:
  D.8507 = p + 8;
  D.8508 = (unsigned int) D.8507;
  D.8512 = -D.8508;
  iftmp.39 = D.8512 & 7;
  goto <D.8513>;
  <D.8511>:
  iftmp.39 = 0;
  <D.8513>:
  offset = iftmp.39;
  p = p + offset;
  psize = psize - offset;
  m->top = p;
  m->topsize = psize;
  D.8514 = psize | 1;
  p->head = D.8514;
  D.8515 = p + psize;
  D.8515->head = 40;
  D.8516 = mparams.trim_threshold;
  m->trim_check = D.8516;
}


prepend_alloc (struct malloc_state * m, char * newbase, char * oldbase, size_t nb)
{
  sizetype iftmp.40;
  void * D.8518;
  unsigned int D.8519;
  unsigned int D.8520;
  unsigned int D.8523;
  sizetype iftmp.41;
  void * D.8526;
  unsigned int D.8527;
  unsigned int D.8528;
  unsigned int D.8531;
  int oldfirst.42;
  int p.43;
  int D.8535;
  unsigned int D.8536;
  struct malloc_chunk * D.8537;
  unsigned int D.8540;
  unsigned int D.8541;
  unsigned int D.8542;
  struct malloc_chunk * D.8544;
  unsigned int D.8547;
  unsigned int D.8548;
  unsigned int D.8549;
  struct malloc_chunk * D.8550;
  unsigned int D.8552;
  unsigned int D.8553;
  unsigned int D.8556;
  unsigned int D.8561;
  int I.44;
  unsigned int D.8563;
  unsigned int D.8564;
  unsigned int D.8565;
  int iftmp.45;
  unsigned int D.8573;
  struct malloc_chunk * * D.8574;
  _Bool D.8575;
  long int D.8576;
  long int D.8577;
  char * D.8579;
  _Bool D.8580;
  long int D.8581;
  long int D.8582;
  int iftmp.46;
  _Bool D.8588;
  long int D.8589;
  long int D.8590;
  _Bool D.8592;
  long int D.8593;
  long int D.8594;
  struct malloc_tree_chunk * D.8597;
  _Bool D.8600;
  long int D.8601;
  long int D.8602;
  struct malloc_tree_chunk * D.8610;
  _Bool D.8612;
  long int D.8613;
  long int D.8614;
  unsigned int D.8620;
  struct malloc_tree_chunk * D.8621;
  unsigned int D.8626;
  int D.8627;
  unsigned int D.8628;
  unsigned int D.8629;
  unsigned int D.8630;
  _Bool D.8632;
  long int D.8633;
  long int D.8634;
  struct malloc_tree_chunk * D.8637;
  _Bool D.8644;
  long int D.8645;
  long int D.8646;
  _Bool D.8651;
  long int D.8652;
  long int D.8653;
  _Bool D.8659;
  long int D.8660;
  long int D.8661;
  unsigned int D.8666;
  unsigned int D.8667;
  struct malloc_chunk * D.8668;
  unsigned int D.8669;
  unsigned int D.8672;
  int I.47;
  unsigned int D.8674;
  unsigned int D.8675;
  unsigned int D.8678;
  struct malloc_chunk * D.8680;
  _Bool D.8681;
  long int D.8682;
  long int D.8683;
  unsigned int D.8694;
  unsigned int D.8695;
  int N.48;
  unsigned int D.8697;
  unsigned int D.8698;
  int K.49;
  unsigned int D.8700;
  unsigned int D.8701;
  unsigned int K.50;
  unsigned int D.8703;
  unsigned int D.8704;
  unsigned int D.8705;
  unsigned int D.8706;
  int D.8707;
  unsigned int D.8708;
  unsigned int D.8709;
  struct malloc_tree_chunk * D.8710;
  int I.51;
  unsigned int D.8712;
  unsigned int D.8713;
  unsigned int D.8716;
  struct malloc_tree_chunk * D.8717;
  int iftmp.52;
  unsigned int D.8722;
  unsigned int D.8723;
  unsigned int D.8725;
  unsigned int D.8726;
  unsigned int D.8729;
  struct malloc_tree_chunk * D.8730;
  _Bool D.8734;
  long int D.8735;
  long int D.8736;
  _Bool D.8741;
  long int D.8742;
  long int D.8743;
  _Bool D.8745;
  long int D.8746;
  long int D.8747;
  struct malloc_tree_chunk * D.8749;
  void * D.8750;
  struct malloc_chunk * p;
  struct malloc_chunk * oldfirst;
  size_t psize;
  struct malloc_chunk * q;
  size_t qsize;

  D.8518 = newbase + 8;
  D.8519 = (unsigned int) D.8518;
  D.8520 = D.8519 & 7;
  if (D.8520 != 0) goto <D.8521>; else goto <D.8522>;
  <D.8521>:
  D.8518 = newbase + 8;
  D.8519 = (unsigned int) D.8518;
  D.8523 = -D.8519;
  iftmp.40 = D.8523 & 7;
  goto <D.8524>;
  <D.8522>:
  iftmp.40 = 0;
  <D.8524>:
  p = newbase + iftmp.40;
  D.8526 = oldbase + 8;
  D.8527 = (unsigned int) D.8526;
  D.8528 = D.8527 & 7;
  if (D.8528 != 0) goto <D.8529>; else goto <D.8530>;
  <D.8529>:
  D.8526 = oldbase + 8;
  D.8527 = (unsigned int) D.8526;
  D.8531 = -D.8527;
  iftmp.41 = D.8531 & 7;
  goto <D.8532>;
  <D.8530>:
  iftmp.41 = 0;
  <D.8532>:
  oldfirst = oldbase + iftmp.41;
  oldfirst.42 = (int) oldfirst;
  p.43 = (int) p;
  D.8535 = oldfirst.42 - p.43;
  psize = (size_t) D.8535;
  q = p + nb;
  qsize = psize - nb;
  D.8536 = nb | 3;
  p->head = D.8536;
  D.8537 = m->top;
  if (D.8537 == oldfirst) goto <D.8538>; else goto <D.8539>;
  <D.8538>:
  {
    size_t tsize;

    D.8540 = m->topsize;
    D.8541 = D.8540 + qsize;
    m->topsize = D.8541;
    tsize = m->topsize;
    m->top = q;
    D.8542 = tsize | 1;
    q->head = D.8542;
  }
  goto <D.8543>;
  <D.8539>:
  D.8544 = m->dv;
  if (D.8544 == oldfirst) goto <D.8545>; else goto <D.8546>;
  <D.8545>:
  {
    size_t dsize;

    D.8547 = m->dvsize;
    D.8548 = D.8547 + qsize;
    m->dvsize = D.8548;
    dsize = m->dvsize;
    m->dv = q;
    D.8549 = dsize | 1;
    q->head = D.8549;
    D.8550 = q + dsize;
    D.8550->prev_foot = dsize;
  }
  goto <D.8551>;
  <D.8546>:
  D.8552 = oldfirst->head;
  D.8553 = D.8552 & 2;
  if (D.8553 == 0) goto <D.8554>; else goto <D.8555>;
  <D.8554>:
  {
    size_t nsize;

    D.8552 = oldfirst->head;
    nsize = D.8552 & 4294967292;
    D.8556 = nsize >> 3;
    if (D.8556 <= 31) goto <D.8557>; else goto <D.8558>;
    <D.8557>:
    {
      struct malloc_chunk * F;
      struct malloc_chunk * B;
      bindex_t I;

      F = oldfirst->fd;
      B = oldfirst->bk;
      I = nsize >> 3;
      if (F == B) goto <D.8559>; else goto <D.8560>;
      <D.8559>:
      D.8561 = m->smallmap;
      I.44 = (int) I;
      D.8563 = 1 << I.44;
      D.8564 = ~D.8563;
      D.8565 = D.8561 & D.8564;
      m->smallmap = D.8565;
      goto <D.8566>;
      <D.8560>:
      D.8573 = I << 1;
      D.8574 = &m->smallbins[D.8573];
      D.8575 = D.8574 == F;
      D.8576 = (long int) D.8575;
      D.8577 = __builtin_expect (D.8576, 1);
      if (D.8577 != 0) goto <D.8570>; else goto <D.8578>;
      <D.8578>:
      D.8579 = m->least_addr;
      D.8580 = D.8579 <= F;
      D.8581 = (long int) D.8580;
      D.8582 = __builtin_expect (D.8581, 1);
      if (D.8582 != 0) goto <D.8570>; else goto <D.8571>;
      <D.8570>:
      iftmp.45 = 1;
      goto <D.8572>;
      <D.8571>:
      iftmp.45 = 0;
      <D.8572>:
      if (iftmp.45 != 0) goto <D.8583>; else goto <D.8567>;
      <D.8583>:
      D.8573 = I << 1;
      D.8574 = &m->smallbins[D.8573];
      D.8588 = D.8574 == B;
      D.8589 = (long int) D.8588;
      D.8590 = __builtin_expect (D.8589, 1);
      if (D.8590 != 0) goto <D.8585>; else goto <D.8591>;
      <D.8591>:
      D.8579 = m->least_addr;
      D.8592 = D.8579 <= B;
      D.8593 = (long int) D.8592;
      D.8594 = __builtin_expect (D.8593, 1);
      if (D.8594 != 0) goto <D.8585>; else goto <D.8586>;
      <D.8585>:
      iftmp.46 = 1;
      goto <D.8587>;
      <D.8586>:
      iftmp.46 = 0;
      <D.8587>:
      if (iftmp.46 != 0) goto <D.8595>; else goto <D.8567>;
      <D.8595>:
      F->bk = B;
      B->fd = F;
      goto <D.8568>;
      <D.8567>:
      abort ();
      <D.8568>:
      <D.8566>:
    }
    goto <D.8596>;
    <D.8558>:
    {
      struct malloc_tree_chunk * TP;

      TP = oldfirst;
      {
        struct malloc_tree_chunk * XP;
        struct malloc_tree_chunk * R;

        XP = TP->parent;
        D.8597 = TP->bk;
        if (D.8597 != TP) goto <D.8598>; else goto <D.8599>;
        <D.8598>:
        {
          struct malloc_tree_chunk * F;

          F = TP->fd;
          R = TP->bk;
          D.8579 = m->least_addr;
          D.8600 = D.8579 <= F;
          D.8601 = (long int) D.8600;
          D.8602 = __builtin_expect (D.8601, 1);
          if (D.8602 != 0) goto <D.8603>; else goto <D.8604>;
          <D.8603>:
          F->bk = R;
          R->fd = F;
          goto <D.8605>;
          <D.8604>:
          abort ();
          <D.8605>:
        }
        goto <D.8606>;
        <D.8599>:
        {
          struct malloc_tree_chunk * * RP;

          RP = &TP->child[1];
          R = *RP;
          if (R != 0B) goto <D.8607>; else goto <D.8609>;
          <D.8609>:
          RP = &TP->child[0];
          R = *RP;
          if (R != 0B) goto <D.8607>; else goto <D.8608>;
          <D.8607>:
          {
            struct malloc_tree_chunk * * CP;

            goto <D.7424>;
            <D.7423>:
            RP = CP;
            R = *RP;
            <D.7424>:
            CP = &R->child[1];
            D.8610 = *CP;
            if (D.8610 != 0B) goto <D.7423>; else goto <D.8611>;
            <D.8611>:
            CP = &R->child[0];
            D.8610 = *CP;
            if (D.8610 != 0B) goto <D.7423>; else goto <D.7425>;
            <D.7425>:
            D.8579 = m->least_addr;
            D.8612 = D.8579 <= RP;
            D.8613 = (long int) D.8612;
            D.8614 = __builtin_expect (D.8613, 1);
            if (D.8614 != 0) goto <D.8615>; else goto <D.8616>;
            <D.8615>:
            *RP = 0B;
            goto <D.8617>;
            <D.8616>:
            abort ();
            <D.8617>:
          }
          <D.8608>:
        }
        <D.8606>:
        if (XP != 0B) goto <D.8618>; else goto <D.8619>;
        <D.8618>:
        {
          struct malloc_tree_chunk * * H;

          D.8620 = TP->index;
          H = &m->treebins[D.8620];
          D.8621 = *H;
          if (D.8621 == TP) goto <D.8622>; else goto <D.8623>;
          <D.8622>:
          *H = R;
          D.8621 = *H;
          if (D.8621 == 0B) goto <D.8624>; else goto <D.8625>;
          <D.8624>:
          D.8626 = m->treemap;
          D.8620 = TP->index;
          D.8627 = (int) D.8620;
          D.8628 = 1 << D.8627;
          D.8629 = ~D.8628;
          D.8630 = D.8626 & D.8629;
          m->treemap = D.8630;
          <D.8625>:
          goto <D.8631>;
          <D.8623>:
          D.8579 = m->least_addr;
          D.8632 = D.8579 <= XP;
          D.8633 = (long int) D.8632;
          D.8634 = __builtin_expect (D.8633, 1);
          if (D.8634 != 0) goto <D.8635>; else goto <D.8636>;
          <D.8635>:
          D.8637 = XP->child[0];
          if (D.8637 == TP) goto <D.8638>; else goto <D.8639>;
          <D.8638>:
          XP->child[0] = R;
          goto <D.8640>;
          <D.8639>:
          XP->child[1] = R;
          <D.8640>:
          goto <D.8641>;
          <D.8636>:
          abort ();
          <D.8641>:
          <D.8631>:
          if (R != 0B) goto <D.8642>; else goto <D.8643>;
          <D.8642>:
          D.8579 = m->least_addr;
          D.8644 = D.8579 <= R;
          D.8645 = (long int) D.8644;
          D.8646 = __builtin_expect (D.8645, 1);
          if (D.8646 != 0) goto <D.8647>; else goto <D.8648>;
          <D.8647>:
          {
            struct malloc_tree_chunk * C0;
            struct malloc_tree_chunk * C1;

            R->parent = XP;
            C0 = TP->child[0];
            if (C0 != 0B) goto <D.8649>; else goto <D.8650>;
            <D.8649>:
            D.8579 = m->least_addr;
            D.8651 = D.8579 <= C0;
            D.8652 = (long int) D.8651;
            D.8653 = __builtin_expect (D.8652, 1);
            if (D.8653 != 0) goto <D.8654>; else goto <D.8655>;
            <D.8654>:
            R->child[0] = C0;
            C0->parent = R;
            goto <D.8656>;
            <D.8655>:
            abort ();
            <D.8656>:
            <D.8650>:
            C1 = TP->child[1];
            if (C1 != 0B) goto <D.8657>; else goto <D.8658>;
            <D.8657>:
            D.8579 = m->least_addr;
            D.8659 = D.8579 <= C1;
            D.8660 = (long int) D.8659;
            D.8661 = __builtin_expect (D.8660, 1);
            if (D.8661 != 0) goto <D.8662>; else goto <D.8663>;
            <D.8662>:
            R->child[1] = C1;
            C1->parent = R;
            goto <D.8664>;
            <D.8663>:
            abort ();
            <D.8664>:
            <D.8658>:
          }
          goto <D.8665>;
          <D.8648>:
          abort ();
          <D.8665>:
          <D.8643>:
        }
        <D.8619>:
      }
    }
    <D.8596>:
    oldfirst = oldfirst + nsize;
    qsize = qsize + nsize;
  }
  <D.8555>:
  D.8552 = oldfirst->head;
  D.8666 = D.8552 & 4294967294;
  oldfirst->head = D.8666;
  D.8667 = qsize | 1;
  q->head = D.8667;
  D.8668 = q + qsize;
  D.8668->prev_foot = qsize;
  D.8669 = qsize >> 3;
  if (D.8669 <= 31) goto <D.8670>; else goto <D.8671>;
  <D.8670>:
  {
    bindex_t I;
    struct malloc_chunk * B;
    struct malloc_chunk * F;

    I = qsize >> 3;
    D.8672 = I << 1;
    B = &m->smallbins[D.8672];
    F = B;
    D.8561 = m->smallmap;
    I.47 = (int) I;
    D.8674 = 1 << I.47;
    D.8675 = D.8561 & D.8674;
    if (D.8675 == 0) goto <D.8676>; else goto <D.8677>;
    <D.8676>:
    D.8561 = m->smallmap;
    I.47 = (int) I;
    D.8674 = 1 << I.47;
    D.8678 = D.8561 | D.8674;
    m->smallmap = D.8678;
    goto <D.8679>;
    <D.8677>:
    D.8680 = B->fd;
    D.8579 = m->least_addr;
    D.8681 = D.8680 >= D.8579;
    D.8682 = (long int) D.8681;
    D.8683 = __builtin_expect (D.8682, 1);
    if (D.8683 != 0) goto <D.8684>; else goto <D.8685>;
    <D.8684>:
    F = B->fd;
    goto <D.8686>;
    <D.8685>:
    abort ();
    <D.8686>:
    <D.8679>:
    B->fd = q;
    F->bk = q;
    q->fd = F;
    q->bk = B;
  }
  goto <D.8687>;
  <D.8671>:
  {
    struct malloc_tree_chunk * TP;

    TP = q;
    {
      struct malloc_tree_chunk * * H;
      bindex_t I;

      {
        size_t X;

        X = qsize >> 8;
        if (X == 0) goto <D.8688>; else goto <D.8689>;
        <D.8688>:
        I = 0;
        goto <D.8690>;
        <D.8689>:
        if (X > 65535) goto <D.8691>; else goto <D.8692>;
        <D.8691>:
        I = 31;
        goto <D.8693>;
        <D.8692>:
        {
          unsigned int Y;
          unsigned int N;
          unsigned int K;

          Y = X;
          D.8694 = Y + 4294967040;
          D.8695 = D.8694 >> 16;
          N = D.8695 & 8;
          N.48 = (int) N;
          Y = Y << N.48;
          D.8697 = Y + 4294963200;
          D.8698 = D.8697 >> 16;
          K = D.8698 & 4;
          N = N + K;
          K.49 = (int) K;
          Y = Y << K.49;
          D.8700 = Y + 4294950912;
          D.8701 = D.8700 >> 16;
          K = D.8701 & 2;
          K.50 = K;
          N = K.50 + N;
          K.49 = (int) K;
          Y = Y << K.49;
          D.8703 = Y >> 15;
          D.8704 = D.8703 - N;
          K = D.8704 + 14;
          D.8705 = K << 1;
          D.8706 = K + 7;
          D.8707 = (int) D.8706;
          D.8708 = qsize >> D.8707;
          D.8709 = D.8708 & 1;
          I = D.8705 + D.8709;
        }
        <D.8693>:
        <D.8690>:
      }
      H = &m->treebins[I];
      TP->index = I;
      TP->child[1] = 0B;
      D.8710 = TP->child[1];
      TP->child[0] = D.8710;
      D.8626 = m->treemap;
      I.51 = (int) I;
      D.8712 = 1 << I.51;
      D.8713 = D.8626 & D.8712;
      if (D.8713 == 0) goto <D.8714>; else goto <D.8715>;
      <D.8714>:
      D.8626 = m->treemap;
      I.51 = (int) I;
      D.8712 = 1 << I.51;
      D.8716 = D.8626 | D.8712;
      m->treemap = D.8716;
      *H = TP;
      TP->parent = H;
      TP->bk = TP;
      D.8717 = TP->bk;
      TP->fd = D.8717;
      goto <D.8718>;
      <D.8715>:
      {
        struct malloc_tree_chunk * T;
        size_t K;

        T = *H;
        if (I != 31) goto <D.8720>; else goto <D.8721>;
        <D.8720>:
        D.8722 = I >> 1;
        D.8723 = 25 - D.8722;
        iftmp.52 = (int) D.8723;
        goto <D.8724>;
        <D.8721>:
        iftmp.52 = 0;
        <D.8724>:
        K = qsize << iftmp.52;
        <D.7444>:
        D.8725 = T->head;
        D.8726 = D.8725 & 4294967292;
        if (D.8726 != qsize) goto <D.8727>; else goto <D.8728>;
        <D.8727>:
        {
          struct malloc_tree_chunk * * C;

          D.8729 = K >> 31;
          C = &T->child[D.8729];
          K = K << 1;
          D.8730 = *C;
          if (D.8730 != 0B) goto <D.8731>; else goto <D.8732>;
          <D.8731>:
          T = *C;
          goto <D.8733>;
          <D.8732>:
          D.8579 = m->least_addr;
          D.8734 = D.8579 <= C;
          D.8735 = (long int) D.8734;
          D.8736 = __builtin_expect (D.8735, 1);
          if (D.8736 != 0) goto <D.8737>; else goto <D.8738>;
          <D.8737>:
          *C = TP;
          TP->parent = T;
          TP->bk = TP;
          D.8717 = TP->bk;
          TP->fd = D.8717;
          goto <D.7442>;
          <D.8738>:
          abort ();
          <D.8733>:
        }
        goto <D.8739>;
        <D.8728>:
        {
          struct malloc_tree_chunk * F;

          F = T->fd;
          D.8579 = m->least_addr;
          D.8741 = D.8579 <= T;
          D.8742 = (long int) D.8741;
          D.8743 = __builtin_expect (D.8742, 1);
          if (D.8743 != 0) goto <D.8744>; else goto <D.8740>;
          <D.8744>:
          D.8579 = m->least_addr;
          D.8745 = D.8579 <= F;
          D.8746 = (long int) D.8745;
          D.8747 = __builtin_expect (D.8746, 1);
          if (D.8747 != 0) goto <D.8748>; else goto <D.8740>;
          <D.8748>:
          F->bk = TP;
          D.8749 = F->bk;
          T->fd = D.8749;
          TP->fd = F;
          TP->bk = T;
          TP->parent = 0B;
          goto <D.7442>;
          <D.8740>:
          abort ();
        }
        <D.8739>:
        goto <D.7444>;
        <D.7442>:
      }
      <D.8718>:
    }
  }
  <D.8687>:
  <D.8551>:
  <D.8543>:
  D.8750 = p + 8;
  return D.8750;
}


add_segment (struct malloc_state * m, char * tbase, size_t tsize, flag_t mmapped)
{
  char * D.8752;
  unsigned int D.8753;
  sizetype D.8754;
  unsigned int iftmp.53;
  void * D.8756;
  unsigned int D.8757;
  unsigned int D.8758;
  unsigned int D.8761;
  char * iftmp.54;
  char * D.8764;
  unsigned int D.8768;
  unsigned int D.8769;
  size_t * D.8770;
  int csp.55;
  int old_top.56;
  int D.8776;
  unsigned int D.8777;
  unsigned int D.8778;
  unsigned int D.8779;
  struct malloc_chunk * D.8780;
  unsigned int D.8781;
  unsigned int D.8784;
  unsigned int D.8785;
  int I.57;
  unsigned int D.8787;
  unsigned int D.8788;
  unsigned int D.8791;
  struct malloc_chunk * D.8793;
  char * D.8794;
  _Bool D.8795;
  long int D.8796;
  long int D.8797;
  unsigned int D.8808;
  unsigned int D.8809;
  int N.58;
  unsigned int D.8811;
  unsigned int D.8812;
  int K.59;
  unsigned int D.8814;
  unsigned int D.8815;
  unsigned int K.60;
  unsigned int D.8817;
  unsigned int D.8818;
  unsigned int D.8819;
  unsigned int D.8820;
  int D.8821;
  unsigned int D.8822;
  unsigned int D.8823;
  struct malloc_tree_chunk * D.8824;
  unsigned int D.8825;
  int I.61;
  unsigned int D.8827;
  unsigned int D.8828;
  unsigned int D.8831;
  struct malloc_tree_chunk * D.8832;
  int iftmp.62;
  unsigned int D.8837;
  unsigned int D.8838;
  unsigned int D.8840;
  unsigned int D.8841;
  unsigned int D.8844;
  struct malloc_tree_chunk * D.8845;
  _Bool D.8849;
  long int D.8850;
  long int D.8851;
  _Bool D.8856;
  long int D.8857;
  long int D.8858;
  _Bool D.8860;
  long int D.8861;
  long int D.8862;
  struct malloc_tree_chunk * D.8864;
  char * old_top;
  struct malloc_segment * oldsp;
  char * old_end;
  size_t ssize;
  char * rawsp;
  size_t offset;
  char * asp;
  char * csp;
  struct malloc_chunk * sp;
  struct malloc_segment * ss;
  struct malloc_chunk * tnext;
  struct malloc_chunk * p;
  int nfences;

  old_top = m->top;
  oldsp = segment_holding (m, old_top);
  D.8752 = oldsp->base;
  D.8753 = oldsp->size;
  old_end = D.8752 + D.8753;
  ssize = 24;
  D.8754 = 4294967273 - ssize;
  rawsp = old_end + D.8754;
  D.8756 = rawsp + 8;
  D.8757 = (unsigned int) D.8756;
  D.8758 = D.8757 & 7;
  if (D.8758 != 0) goto <D.8759>; else goto <D.8760>;
  <D.8759>:
  D.8756 = rawsp + 8;
  D.8757 = (unsigned int) D.8756;
  D.8761 = -D.8757;
  iftmp.53 = D.8761 & 7;
  goto <D.8762>;
  <D.8760>:
  iftmp.53 = 0;
  <D.8762>:
  offset = iftmp.53;
  asp = rawsp + offset;
  D.8764 = old_top + 16;
  if (D.8764 > asp) goto <D.8765>; else goto <D.8766>;
  <D.8765>:
  iftmp.54 = old_top;
  goto <D.8767>;
  <D.8766>:
  iftmp.54 = asp;
  <D.8767>:
  csp = iftmp.54;
  sp = csp;
  ss = sp + 8;
  tnext = sp + ssize;
  p = tnext;
  nfences = 0;
  D.8768 = tsize + 4294967256;
  init_top (m, tbase, D.8768);
  D.8769 = ssize | 3;
  sp->head = D.8769;
  *ss = m->seg;
  m->seg.base = tbase;
  m->seg.size = tsize;
  m->seg.sflags = mmapped;
  m->seg.next = ss;
  <D.7466>:
  {
    struct malloc_chunk * nextp;

    nextp = p + 4;
    p->head = 7;
    nfences = nfences + 1;
    D.8770 = &nextp->head;
    if (D.8770 < old_end) goto <D.8771>; else goto <D.7465>;
    <D.8771>:
    p = nextp;
  }
  goto <D.7466>;
  <D.7465>:
  if (csp != old_top) goto <D.8772>; else goto <D.8773>;
  <D.8772>:
  {
    struct malloc_chunk * q;
    size_t psize;
    struct malloc_chunk * tn;

    q = old_top;
    csp.55 = (int) csp;
    old_top.56 = (int) old_top;
    D.8776 = csp.55 - old_top.56;
    psize = (size_t) D.8776;
    tn = q + psize;
    D.8777 = tn->head;
    D.8778 = D.8777 & 4294967294;
    tn->head = D.8778;
    D.8779 = psize | 1;
    q->head = D.8779;
    D.8780 = q + psize;
    D.8780->prev_foot = psize;
    D.8781 = psize >> 3;
    if (D.8781 <= 31) goto <D.8782>; else goto <D.8783>;
    <D.8782>:
    {
      bindex_t I;
      struct malloc_chunk * B;
      struct malloc_chunk * F;

      I = psize >> 3;
      D.8784 = I << 1;
      B = &m->smallbins[D.8784];
      F = B;
      D.8785 = m->smallmap;
      I.57 = (int) I;
      D.8787 = 1 << I.57;
      D.8788 = D.8785 & D.8787;
      if (D.8788 == 0) goto <D.8789>; else goto <D.8790>;
      <D.8789>:
      D.8785 = m->smallmap;
      I.57 = (int) I;
      D.8787 = 1 << I.57;
      D.8791 = D.8785 | D.8787;
      m->smallmap = D.8791;
      goto <D.8792>;
      <D.8790>:
      D.8793 = B->fd;
      D.8794 = m->least_addr;
      D.8795 = D.8793 >= D.8794;
      D.8796 = (long int) D.8795;
      D.8797 = __builtin_expect (D.8796, 1);
      if (D.8797 != 0) goto <D.8798>; else goto <D.8799>;
      <D.8798>:
      F = B->fd;
      goto <D.8800>;
      <D.8799>:
      abort ();
      <D.8800>:
      <D.8792>:
      B->fd = q;
      F->bk = q;
      q->fd = F;
      q->bk = B;
    }
    goto <D.8801>;
    <D.8783>:
    {
      struct malloc_tree_chunk * TP;

      TP = q;
      {
        struct malloc_tree_chunk * * H;
        bindex_t I;

        {
          size_t X;

          X = psize >> 8;
          if (X == 0) goto <D.8802>; else goto <D.8803>;
          <D.8802>:
          I = 0;
          goto <D.8804>;
          <D.8803>:
          if (X > 65535) goto <D.8805>; else goto <D.8806>;
          <D.8805>:
          I = 31;
          goto <D.8807>;
          <D.8806>:
          {
            unsigned int Y;
            unsigned int N;
            unsigned int K;

            Y = X;
            D.8808 = Y + 4294967040;
            D.8809 = D.8808 >> 16;
            N = D.8809 & 8;
            N.58 = (int) N;
            Y = Y << N.58;
            D.8811 = Y + 4294963200;
            D.8812 = D.8811 >> 16;
            K = D.8812 & 4;
            N = N + K;
            K.59 = (int) K;
            Y = Y << K.59;
            D.8814 = Y + 4294950912;
            D.8815 = D.8814 >> 16;
            K = D.8815 & 2;
            K.60 = K;
            N = K.60 + N;
            K.59 = (int) K;
            Y = Y << K.59;
            D.8817 = Y >> 15;
            D.8818 = D.8817 - N;
            K = D.8818 + 14;
            D.8819 = K << 1;
            D.8820 = K + 7;
            D.8821 = (int) D.8820;
            D.8822 = psize >> D.8821;
            D.8823 = D.8822 & 1;
            I = D.8819 + D.8823;
          }
          <D.8807>:
          <D.8804>:
        }
        H = &m->treebins[I];
        TP->index = I;
        TP->child[1] = 0B;
        D.8824 = TP->child[1];
        TP->child[0] = D.8824;
        D.8825 = m->treemap;
        I.61 = (int) I;
        D.8827 = 1 << I.61;
        D.8828 = D.8825 & D.8827;
        if (D.8828 == 0) goto <D.8829>; else goto <D.8830>;
        <D.8829>:
        D.8825 = m->treemap;
        I.61 = (int) I;
        D.8827 = 1 << I.61;
        D.8831 = D.8825 | D.8827;
        m->treemap = D.8831;
        *H = TP;
        TP->parent = H;
        TP->bk = TP;
        D.8832 = TP->bk;
        TP->fd = D.8832;
        goto <D.8833>;
        <D.8830>:
        {
          struct malloc_tree_chunk * T;
          size_t K;

          T = *H;
          if (I != 31) goto <D.8835>; else goto <D.8836>;
          <D.8835>:
          D.8837 = I >> 1;
          D.8838 = 25 - D.8837;
          iftmp.62 = (int) D.8838;
          goto <D.8839>;
          <D.8836>:
          iftmp.62 = 0;
          <D.8839>:
          K = psize << iftmp.62;
          <D.7485>:
          D.8840 = T->head;
          D.8841 = D.8840 & 4294967292;
          if (D.8841 != psize) goto <D.8842>; else goto <D.8843>;
          <D.8842>:
          {
            struct malloc_tree_chunk * * C;

            D.8844 = K >> 31;
            C = &T->child[D.8844];
            K = K << 1;
            D.8845 = *C;
            if (D.8845 != 0B) goto <D.8846>; else goto <D.8847>;
            <D.8846>:
            T = *C;
            goto <D.8848>;
            <D.8847>:
            D.8794 = m->least_addr;
            D.8849 = D.8794 <= C;
            D.8850 = (long int) D.8849;
            D.8851 = __builtin_expect (D.8850, 1);
            if (D.8851 != 0) goto <D.8852>; else goto <D.8853>;
            <D.8852>:
            *C = TP;
            TP->parent = T;
            TP->bk = TP;
            D.8832 = TP->bk;
            TP->fd = D.8832;
            goto <D.7483>;
            <D.8853>:
            abort ();
            <D.8848>:
          }
          goto <D.8854>;
          <D.8843>:
          {
            struct malloc_tree_chunk * F;

            F = T->fd;
            D.8794 = m->least_addr;
            D.8856 = D.8794 <= T;
            D.8857 = (long int) D.8856;
            D.8858 = __builtin_expect (D.8857, 1);
            if (D.8858 != 0) goto <D.8859>; else goto <D.8855>;
            <D.8859>:
            D.8794 = m->least_addr;
            D.8860 = D.8794 <= F;
            D.8861 = (long int) D.8860;
            D.8862 = __builtin_expect (D.8861, 1);
            if (D.8862 != 0) goto <D.8863>; else goto <D.8855>;
            <D.8863>:
            F->bk = TP;
            D.8864 = F->bk;
            T->fd = D.8864;
            TP->fd = F;
            TP->bk = T;
            TP->parent = 0B;
            goto <D.7483>;
            <D.8855>:
            abort ();
          }
          <D.8854>:
          goto <D.7485>;
          <D.7483>:
        }
        <D.8833>:
      }
    }
    <D.8801>:
  }
  <D.8773>:
}


segment_holding (struct malloc_state * m, char * addr)
{
  char * D.8865;
  unsigned int D.8868;
  char * D.8869;
  struct malloc_segment * D.8872;
  struct malloc_segment * sp;

  sp = &m->seg;
  <D.7366>:
  D.8865 = sp->base;
  if (D.8865 <= addr) goto <D.8866>; else goto <D.8867>;
  <D.8866>:
  D.8865 = sp->base;
  D.8868 = sp->size;
  D.8869 = D.8865 + D.8868;
  if (D.8869 > addr) goto <D.8870>; else goto <D.8871>;
  <D.8870>:
  D.8872 = sp;
  return D.8872;
  <D.8871>:
  <D.8867>:
  sp = sp->next;
  if (sp == 0B) goto <D.8873>; else goto <D.8874>;
  <D.8873>:
  D.8872 = 0B;
  return D.8872;
  <D.8874>:
  goto <D.7366>;
}


dlfree (void * mem)
{
  unsigned int D.8882;
  int D.8884;
  unsigned int D.8885;
  unsigned int D.8886;
  int D.8887;
  char * D.8888;
  _Bool D.8889;
  long int D.8890;
  long int D.8891;
  unsigned int D.8894;
  unsigned int D.8895;
  _Bool D.8896;
  long int D.8897;
  long int D.8898;
  unsigned int D.8901;
  unsigned int D.8904;
  unsigned int D.8907;
  sizetype D.8908;
  void * D.8909;
  int D.8910;
  unsigned int D.8913;
  unsigned int D.8914;
  _Bool D.8915;
  long int D.8916;
  long int D.8917;
  struct malloc_chunk * D.8919;
  unsigned int D.8922;
  unsigned int D.8927;
  int I.63;
  unsigned int D.8929;
  unsigned int D.8930;
  unsigned int D.8931;
  int iftmp.64;
  unsigned int D.8939;
  struct malloc_chunk * * D.8940;
  _Bool D.8941;
  long int D.8942;
  long int D.8943;
  _Bool D.8945;
  long int D.8946;
  long int D.8947;
  int iftmp.65;
  _Bool D.8953;
  long int D.8954;
  long int D.8955;
  _Bool D.8957;
  long int D.8958;
  long int D.8959;
  struct malloc_tree_chunk * D.8962;
  _Bool D.8965;
  long int D.8966;
  long int D.8967;
  struct malloc_tree_chunk * D.8975;
  _Bool D.8977;
  long int D.8978;
  long int D.8979;
  unsigned int D.8985;
  struct malloc_tree_chunk * D.8986;
  unsigned int D.8991;
  int D.8992;
  unsigned int D.8993;
  unsigned int D.8994;
  unsigned int D.8995;
  _Bool D.8997;
  long int D.8998;
  long int D.8999;
  struct malloc_tree_chunk * D.9002;
  _Bool D.9009;
  long int D.9010;
  long int D.9011;
  _Bool D.9016;
  long int D.9017;
  long int D.9018;
  _Bool D.9024;
  long int D.9025;
  long int D.9026;
  unsigned int D.9032;
  unsigned int D.9033;
  unsigned int D.9036;
  unsigned int D.9037;
  struct malloc_chunk * D.9038;
  _Bool D.9039;
  long int D.9040;
  long int D.9041;
  unsigned int D.9044;
  _Bool D.9045;
  long int D.9046;
  long int D.9047;
  unsigned int D.9050;
  struct malloc_chunk * D.9053;
  unsigned int D.9056;
  unsigned int D.9057;
  unsigned int D.9058;
  unsigned int D.9061;
  unsigned int D.9066;
  unsigned int D.9067;
  unsigned int D.9068;
  struct malloc_chunk * D.9069;
  unsigned int D.9070;
  int I.66;
  unsigned int D.9076;
  unsigned int D.9077;
  unsigned int D.9078;
  int iftmp.67;
  unsigned int D.9086;
  struct malloc_chunk * * D.9087;
  _Bool D.9088;
  long int D.9089;
  long int D.9090;
  _Bool D.9092;
  long int D.9093;
  long int D.9094;
  int iftmp.68;
  _Bool D.9100;
  long int D.9101;
  long int D.9102;
  _Bool D.9104;
  long int D.9105;
  long int D.9106;
  struct malloc_tree_chunk * D.9109;
  _Bool D.9112;
  long int D.9113;
  long int D.9114;
  struct malloc_tree_chunk * D.9122;
  _Bool D.9124;
  long int D.9125;
  long int D.9126;
  unsigned int D.9132;
  struct malloc_tree_chunk * D.9133;
  int D.9138;
  unsigned int D.9139;
  unsigned int D.9140;
  unsigned int D.9141;
  _Bool D.9143;
  long int D.9144;
  long int D.9145;
  struct malloc_tree_chunk * D.9148;
  _Bool D.9155;
  long int D.9156;
  long int D.9157;
  _Bool D.9162;
  long int D.9163;
  long int D.9164;
  _Bool D.9170;
  long int D.9171;
  long int D.9172;
  unsigned int D.9180;
  unsigned int D.9183;
  int I.69;
  unsigned int D.9185;
  unsigned int D.9186;
  unsigned int D.9189;
  struct malloc_chunk * D.9191;
  _Bool D.9192;
  long int D.9193;
  long int D.9194;
  unsigned int D.9205;
  unsigned int D.9206;
  int N.70;
  unsigned int D.9208;
  unsigned int D.9209;
  int K.71;
  unsigned int D.9211;
  unsigned int D.9212;
  unsigned int K.72;
  unsigned int D.9214;
  unsigned int D.9215;
  unsigned int D.9216;
  unsigned int D.9217;
  int D.9218;
  unsigned int D.9219;
  unsigned int D.9220;
  struct malloc_tree_chunk * D.9221;
  int I.73;
  unsigned int D.9223;
  unsigned int D.9224;
  unsigned int D.9227;
  struct malloc_tree_chunk * D.9228;
  int iftmp.74;
  unsigned int D.9233;
  unsigned int D.9234;
  unsigned int D.9236;
  unsigned int D.9237;
  unsigned int D.9240;
  struct malloc_tree_chunk * D.9241;
  _Bool D.9245;
  long int D.9246;
  long int D.9247;
  _Bool D.9252;
  long int D.9253;
  long int D.9254;
  _Bool D.9256;
  long int D.9257;
  long int D.9258;
  struct malloc_tree_chunk * D.9260;
  void postaction = <<< error >>>;
  void erroraction = <<< error >>>;

  if (mem != 0B) goto <D.8876>; else goto <D.8877>;
  <D.8876>:
  {
    struct malloc_chunk * p;

    p = mem + 4294967288;
    D.8882 = mparams.page_size;
    if (D.8882 != 0) goto <D.8878>; else goto <D.8883>;
    <D.8883>:
    D.8884 = init_mparams ();
    if (D.8884 == 0) goto <D.8878>; else goto <D.8879>;
    <D.8878>:
    D.8885 = _gm_.mflags;
    D.8886 = D.8885 & 2;
    if (D.8886 == 0) goto <D.8880>; else goto <D.8879>;
    <D.8879>:
    D.8887 = pthread_mutex_lock (&_gm_.mutex);
    if (D.8887 == 0) goto <D.8880>; else goto <D.8881>;
    <D.8880>:
    D.8888 = _gm_.least_addr;
    D.8889 = D.8888 <= p;
    D.8890 = (long int) D.8889;
    D.8891 = __builtin_expect (D.8890, 1);
    if (D.8891 != 0) goto <D.8892>; else goto <D.8893>;
    <D.8892>:
    D.8894 = p->head;
    D.8895 = D.8894 & 2;
    D.8896 = D.8895 != 0;
    D.8897 = (long int) D.8896;
    D.8898 = __builtin_expect (D.8897, 1);
    if (D.8898 != 0) goto <D.8899>; else goto <D.8900>;
    <D.8899>:
    {
      size_t psize;
      struct malloc_chunk * next;

      D.8894 = p->head;
      psize = D.8894 & 4294967292;
      next = p + psize;
      D.8894 = p->head;
      D.8901 = D.8894 & 1;
      if (D.8901 == 0) goto <D.8902>; else goto <D.8903>;
      <D.8902>:
      {
        size_t prevsize;

        prevsize = p->prev_foot;
        D.8904 = prevsize & 1;
        if (D.8904 != 0) goto <D.8905>; else goto <D.8906>;
        <D.8905>:
        prevsize = prevsize & 4294967294;
        D.8907 = prevsize + psize;
        psize = D.8907 + 16;
        D.8908 = -prevsize;
        D.8909 = p + D.8908;
        D.8910 = munmap (D.8909, psize);
        if (D.8910 == 0) goto <D.8911>; else goto <D.8912>;
        <D.8911>:
        D.8913 = _gm_.footprint;
        D.8914 = D.8913 - psize;
        _gm_.footprint = D.8914;
        <D.8912>:
        goto postaction;
        <D.8906>:
        {
          struct malloc_chunk * prev;

          D.8908 = -prevsize;
          prev = p + D.8908;
          psize = psize + prevsize;
          p = prev;
          D.8888 = _gm_.least_addr;
          D.8915 = D.8888 <= prev;
          D.8916 = (long int) D.8915;
          D.8917 = __builtin_expect (D.8916, 1);
          if (D.8917 != 0) goto <D.8918>; else goto erroraction;
          <D.8918>:
          D.8919 = _gm_.dv;
          if (D.8919 != p) goto <D.8920>; else goto <D.8921>;
          <D.8920>:
          D.8922 = prevsize >> 3;
          if (D.8922 <= 31) goto <D.8923>; else goto <D.8924>;
          <D.8923>:
          {
            struct malloc_chunk * F;
            struct malloc_chunk * B;
            bindex_t I;

            F = p->fd;
            B = p->bk;
            I = prevsize >> 3;
            if (F == B) goto <D.8925>; else goto <D.8926>;
            <D.8925>:
            D.8927 = _gm_.smallmap;
            I.63 = (int) I;
            D.8929 = 1 << I.63;
            D.8930 = ~D.8929;
            D.8931 = D.8927 & D.8930;
            _gm_.smallmap = D.8931;
            goto <D.8932>;
            <D.8926>:
            D.8939 = I << 1;
            D.8940 = &_gm_.smallbins[D.8939];
            D.8941 = D.8940 == F;
            D.8942 = (long int) D.8941;
            D.8943 = __builtin_expect (D.8942, 1);
            if (D.8943 != 0) goto <D.8936>; else goto <D.8944>;
            <D.8944>:
            D.8888 = _gm_.least_addr;
            D.8945 = D.8888 <= F;
            D.8946 = (long int) D.8945;
            D.8947 = __builtin_expect (D.8946, 1);
            if (D.8947 != 0) goto <D.8936>; else goto <D.8937>;
            <D.8936>:
            iftmp.64 = 1;
            goto <D.8938>;
            <D.8937>:
            iftmp.64 = 0;
            <D.8938>:
            if (iftmp.64 != 0) goto <D.8948>; else goto <D.8933>;
            <D.8948>:
            D.8939 = I << 1;
            D.8940 = &_gm_.smallbins[D.8939];
            D.8953 = D.8940 == B;
            D.8954 = (long int) D.8953;
            D.8955 = __builtin_expect (D.8954, 1);
            if (D.8955 != 0) goto <D.8950>; else goto <D.8956>;
            <D.8956>:
            D.8888 = _gm_.least_addr;
            D.8957 = D.8888 <= B;
            D.8958 = (long int) D.8957;
            D.8959 = __builtin_expect (D.8958, 1);
            if (D.8959 != 0) goto <D.8950>; else goto <D.8951>;
            <D.8950>:
            iftmp.65 = 1;
            goto <D.8952>;
            <D.8951>:
            iftmp.65 = 0;
            <D.8952>:
            if (iftmp.65 != 0) goto <D.8960>; else goto <D.8933>;
            <D.8960>:
            F->bk = B;
            B->fd = F;
            goto <D.8934>;
            <D.8933>:
            abort ();
            <D.8934>:
            <D.8932>:
          }
          goto <D.8961>;
          <D.8924>:
          {
            struct malloc_tree_chunk * TP;

            TP = p;
            {
              struct malloc_tree_chunk * XP;
              struct malloc_tree_chunk * R;

              XP = TP->parent;
              D.8962 = TP->bk;
              if (D.8962 != TP) goto <D.8963>; else goto <D.8964>;
              <D.8963>:
              {
                struct malloc_tree_chunk * F;

                F = TP->fd;
                R = TP->bk;
                D.8888 = _gm_.least_addr;
                D.8965 = D.8888 <= F;
                D.8966 = (long int) D.8965;
                D.8967 = __builtin_expect (D.8966, 1);
                if (D.8967 != 0) goto <D.8968>; else goto <D.8969>;
                <D.8968>:
                F->bk = R;
                R->fd = F;
                goto <D.8970>;
                <D.8969>:
                abort ();
                <D.8970>:
              }
              goto <D.8971>;
              <D.8964>:
              {
                struct malloc_tree_chunk * * RP;

                RP = &TP->child[1];
                R = *RP;
                if (R != 0B) goto <D.8972>; else goto <D.8974>;
                <D.8974>:
                RP = &TP->child[0];
                R = *RP;
                if (R != 0B) goto <D.8972>; else goto <D.8973>;
                <D.8972>:
                {
                  struct malloc_tree_chunk * * CP;

                  goto <D.7734>;
                  <D.7733>:
                  RP = CP;
                  R = *RP;
                  <D.7734>:
                  CP = &R->child[1];
                  D.8975 = *CP;
                  if (D.8975 != 0B) goto <D.7733>; else goto <D.8976>;
                  <D.8976>:
                  CP = &R->child[0];
                  D.8975 = *CP;
                  if (D.8975 != 0B) goto <D.7733>; else goto <D.7735>;
                  <D.7735>:
                  D.8888 = _gm_.least_addr;
                  D.8977 = D.8888 <= RP;
                  D.8978 = (long int) D.8977;
                  D.8979 = __builtin_expect (D.8978, 1);
                  if (D.8979 != 0) goto <D.8980>; else goto <D.8981>;
                  <D.8980>:
                  *RP = 0B;
                  goto <D.8982>;
                  <D.8981>:
                  abort ();
                  <D.8982>:
                }
                <D.8973>:
              }
              <D.8971>:
              if (XP != 0B) goto <D.8983>; else goto <D.8984>;
              <D.8983>:
              {
                struct malloc_tree_chunk * * H;

                D.8985 = TP->index;
                H = &_gm_.treebins[D.8985];
                D.8986 = *H;
                if (D.8986 == TP) goto <D.8987>; else goto <D.8988>;
                <D.8987>:
                *H = R;
                D.8986 = *H;
                if (D.8986 == 0B) goto <D.8989>; else goto <D.8990>;
                <D.8989>:
                D.8991 = _gm_.treemap;
                D.8985 = TP->index;
                D.8992 = (int) D.8985;
                D.8993 = 1 << D.8992;
                D.8994 = ~D.8993;
                D.8995 = D.8991 & D.8994;
                _gm_.treemap = D.8995;
                <D.8990>:
                goto <D.8996>;
                <D.8988>:
                D.8888 = _gm_.least_addr;
                D.8997 = D.8888 <= XP;
                D.8998 = (long int) D.8997;
                D.8999 = __builtin_expect (D.8998, 1);
                if (D.8999 != 0) goto <D.9000>; else goto <D.9001>;
                <D.9000>:
                D.9002 = XP->child[0];
                if (D.9002 == TP) goto <D.9003>; else goto <D.9004>;
                <D.9003>:
                XP->child[0] = R;
                goto <D.9005>;
                <D.9004>:
                XP->child[1] = R;
                <D.9005>:
                goto <D.9006>;
                <D.9001>:
                abort ();
                <D.9006>:
                <D.8996>:
                if (R != 0B) goto <D.9007>; else goto <D.9008>;
                <D.9007>:
                D.8888 = _gm_.least_addr;
                D.9009 = D.8888 <= R;
                D.9010 = (long int) D.9009;
                D.9011 = __builtin_expect (D.9010, 1);
                if (D.9011 != 0) goto <D.9012>; else goto <D.9013>;
                <D.9012>:
                {
                  struct malloc_tree_chunk * C0;
                  struct malloc_tree_chunk * C1;

                  R->parent = XP;
                  C0 = TP->child[0];
                  if (C0 != 0B) goto <D.9014>; else goto <D.9015>;
                  <D.9014>:
                  D.8888 = _gm_.least_addr;
                  D.9016 = D.8888 <= C0;
                  D.9017 = (long int) D.9016;
                  D.9018 = __builtin_expect (D.9017, 1);
                  if (D.9018 != 0) goto <D.9019>; else goto <D.9020>;
                  <D.9019>:
                  R->child[0] = C0;
                  C0->parent = R;
                  goto <D.9021>;
                  <D.9020>:
                  abort ();
                  <D.9021>:
                  <D.9015>:
                  C1 = TP->child[1];
                  if (C1 != 0B) goto <D.9022>; else goto <D.9023>;
                  <D.9022>:
                  D.8888 = _gm_.least_addr;
                  D.9024 = D.8888 <= C1;
                  D.9025 = (long int) D.9024;
                  D.9026 = __builtin_expect (D.9025, 1);
                  if (D.9026 != 0) goto <D.9027>; else goto <D.9028>;
                  <D.9027>:
                  R->child[1] = C1;
                  C1->parent = R;
                  goto <D.9029>;
                  <D.9028>:
                  abort ();
                  <D.9029>:
                  <D.9023>:
                }
                goto <D.9030>;
                <D.9013>:
                abort ();
                <D.9030>:
                <D.9008>:
              }
              <D.8984>:
            }
          }
          <D.8961>:
          goto <D.9031>;
          <D.8921>:
          D.9032 = next->head;
          D.9033 = D.9032 & 3;
          if (D.9033 == 3) goto <D.9034>; else goto <D.9035>;
          <D.9034>:
          _gm_.dvsize = psize;
          D.9032 = next->head;
          D.9036 = D.9032 & 4294967294;
          next->head = D.9036;
          D.9037 = psize | 1;
          p->head = D.9037;
          D.9038 = p + psize;
          D.9038->prev_foot = psize;
          goto postaction;
          <D.9035>:
          <D.9031>:
        }
      }
      <D.8903>:
      D.9039 = p < next;
      D.9040 = (long int) D.9039;
      D.9041 = __builtin_expect (D.9040, 1);
      if (D.9041 != 0) goto <D.9042>; else goto <D.9043>;
      <D.9042>:
      D.9032 = next->head;
      D.9044 = D.9032 & 1;
      D.9045 = D.9044 != 0;
      D.9046 = (long int) D.9045;
      D.9047 = __builtin_expect (D.9046, 1);
      if (D.9047 != 0) goto <D.9048>; else goto <D.9049>;
      <D.9048>:
      D.9032 = next->head;
      D.9050 = D.9032 & 2;
      if (D.9050 == 0) goto <D.9051>; else goto <D.9052>;
      <D.9051>:
      D.9053 = _gm_.top;
      if (D.9053 == next) goto <D.9054>; else goto <D.9055>;
      <D.9054>:
      {
        size_t tsize;

        D.9056 = _gm_.topsize;
        D.9057 = D.9056 + psize;
        _gm_.topsize = D.9057;
        tsize = _gm_.topsize;
        _gm_.top = p;
        D.9058 = tsize | 1;
        p->head = D.9058;
        D.8919 = _gm_.dv;
        if (D.8919 == p) goto <D.9059>; else goto <D.9060>;
        <D.9059>:
        _gm_.dv = 0B;
        _gm_.dvsize = 0;
        <D.9060>:
        D.9061 = _gm_.trim_check;
        if (D.9061 < tsize) goto <D.9062>; else goto <D.9063>;
        <D.9062>:
        sys_trim (&_gm_, 0);
        <D.9063>:
        goto postaction;
      }
      <D.9055>:
      D.8919 = _gm_.dv;
      if (D.8919 == next) goto <D.9064>; else goto <D.9065>;
      <D.9064>:
      {
        size_t dsize;

        D.9066 = _gm_.dvsize;
        D.9067 = D.9066 + psize;
        _gm_.dvsize = D.9067;
        dsize = _gm_.dvsize;
        _gm_.dv = p;
        D.9068 = dsize | 1;
        p->head = D.9068;
        D.9069 = p + dsize;
        D.9069->prev_foot = dsize;
        goto postaction;
      }
      <D.9065>:
      {
        size_t nsize;

        D.9032 = next->head;
        nsize = D.9032 & 4294967292;
        psize = psize + nsize;
        D.9070 = nsize >> 3;
        if (D.9070 <= 31) goto <D.9071>; else goto <D.9072>;
        <D.9071>:
        {
          struct malloc_chunk * F;
          struct malloc_chunk * B;
          bindex_t I;

          F = next->fd;
          B = next->bk;
          I = nsize >> 3;
          if (F == B) goto <D.9073>; else goto <D.9074>;
          <D.9073>:
          D.8927 = _gm_.smallmap;
          I.66 = (int) I;
          D.9076 = 1 << I.66;
          D.9077 = ~D.9076;
          D.9078 = D.8927 & D.9077;
          _gm_.smallmap = D.9078;
          goto <D.9079>;
          <D.9074>:
          D.9086 = I << 1;
          D.9087 = &_gm_.smallbins[D.9086];
          D.9088 = D.9087 == F;
          D.9089 = (long int) D.9088;
          D.9090 = __builtin_expect (D.9089, 1);
          if (D.9090 != 0) goto <D.9083>; else goto <D.9091>;
          <D.9091>:
          D.8888 = _gm_.least_addr;
          D.9092 = D.8888 <= F;
          D.9093 = (long int) D.9092;
          D.9094 = __builtin_expect (D.9093, 1);
          if (D.9094 != 0) goto <D.9083>; else goto <D.9084>;
          <D.9083>:
          iftmp.67 = 1;
          goto <D.9085>;
          <D.9084>:
          iftmp.67 = 0;
          <D.9085>:
          if (iftmp.67 != 0) goto <D.9095>; else goto <D.9080>;
          <D.9095>:
          D.9086 = I << 1;
          D.9087 = &_gm_.smallbins[D.9086];
          D.9100 = D.9087 == B;
          D.9101 = (long int) D.9100;
          D.9102 = __builtin_expect (D.9101, 1);
          if (D.9102 != 0) goto <D.9097>; else goto <D.9103>;
          <D.9103>:
          D.8888 = _gm_.least_addr;
          D.9104 = D.8888 <= B;
          D.9105 = (long int) D.9104;
          D.9106 = __builtin_expect (D.9105, 1);
          if (D.9106 != 0) goto <D.9097>; else goto <D.9098>;
          <D.9097>:
          iftmp.68 = 1;
          goto <D.9099>;
          <D.9098>:
          iftmp.68 = 0;
          <D.9099>:
          if (iftmp.68 != 0) goto <D.9107>; else goto <D.9080>;
          <D.9107>:
          F->bk = B;
          B->fd = F;
          goto <D.9081>;
          <D.9080>:
          abort ();
          <D.9081>:
          <D.9079>:
        }
        goto <D.9108>;
        <D.9072>:
        {
          struct malloc_tree_chunk * TP;

          TP = next;
          {
            struct malloc_tree_chunk * XP;
            struct malloc_tree_chunk * R;

            XP = TP->parent;
            D.9109 = TP->bk;
            if (D.9109 != TP) goto <D.9110>; else goto <D.9111>;
            <D.9110>:
            {
              struct malloc_tree_chunk * F;

              F = TP->fd;
              R = TP->bk;
              D.8888 = _gm_.least_addr;
              D.9112 = D.8888 <= F;
              D.9113 = (long int) D.9112;
              D.9114 = __builtin_expect (D.9113, 1);
              if (D.9114 != 0) goto <D.9115>; else goto <D.9116>;
              <D.9115>:
              F->bk = R;
              R->fd = F;
              goto <D.9117>;
              <D.9116>:
              abort ();
              <D.9117>:
            }
            goto <D.9118>;
            <D.9111>:
            {
              struct malloc_tree_chunk * * RP;

              RP = &TP->child[1];
              R = *RP;
              if (R != 0B) goto <D.9119>; else goto <D.9121>;
              <D.9121>:
              RP = &TP->child[0];
              R = *RP;
              if (R != 0B) goto <D.9119>; else goto <D.9120>;
              <D.9119>:
              {
                struct malloc_tree_chunk * * CP;

                goto <D.7753>;
                <D.7752>:
                RP = CP;
                R = *RP;
                <D.7753>:
                CP = &R->child[1];
                D.9122 = *CP;
                if (D.9122 != 0B) goto <D.7752>; else goto <D.9123>;
                <D.9123>:
                CP = &R->child[0];
                D.9122 = *CP;
                if (D.9122 != 0B) goto <D.7752>; else goto <D.7754>;
                <D.7754>:
                D.8888 = _gm_.least_addr;
                D.9124 = D.8888 <= RP;
                D.9125 = (long int) D.9124;
                D.9126 = __builtin_expect (D.9125, 1);
                if (D.9126 != 0) goto <D.9127>; else goto <D.9128>;
                <D.9127>:
                *RP = 0B;
                goto <D.9129>;
                <D.9128>:
                abort ();
                <D.9129>:
              }
              <D.9120>:
            }
            <D.9118>:
            if (XP != 0B) goto <D.9130>; else goto <D.9131>;
            <D.9130>:
            {
              struct malloc_tree_chunk * * H;

              D.9132 = TP->index;
              H = &_gm_.treebins[D.9132];
              D.9133 = *H;
              if (D.9133 == TP) goto <D.9134>; else goto <D.9135>;
              <D.9134>:
              *H = R;
              D.9133 = *H;
              if (D.9133 == 0B) goto <D.9136>; else goto <D.9137>;
              <D.9136>:
              D.8991 = _gm_.treemap;
              D.9132 = TP->index;
              D.9138 = (int) D.9132;
              D.9139 = 1 << D.9138;
              D.9140 = ~D.9139;
              D.9141 = D.8991 & D.9140;
              _gm_.treemap = D.9141;
              <D.9137>:
              goto <D.9142>;
              <D.9135>:
              D.8888 = _gm_.least_addr;
              D.9143 = D.8888 <= XP;
              D.9144 = (long int) D.9143;
              D.9145 = __builtin_expect (D.9144, 1);
              if (D.9145 != 0) goto <D.9146>; else goto <D.9147>;
              <D.9146>:
              D.9148 = XP->child[0];
              if (D.9148 == TP) goto <D.9149>; else goto <D.9150>;
              <D.9149>:
              XP->child[0] = R;
              goto <D.9151>;
              <D.9150>:
              XP->child[1] = R;
              <D.9151>:
              goto <D.9152>;
              <D.9147>:
              abort ();
              <D.9152>:
              <D.9142>:
              if (R != 0B) goto <D.9153>; else goto <D.9154>;
              <D.9153>:
              D.8888 = _gm_.least_addr;
              D.9155 = D.8888 <= R;
              D.9156 = (long int) D.9155;
              D.9157 = __builtin_expect (D.9156, 1);
              if (D.9157 != 0) goto <D.9158>; else goto <D.9159>;
              <D.9158>:
              {
                struct malloc_tree_chunk * C0;
                struct malloc_tree_chunk * C1;

                R->parent = XP;
                C0 = TP->child[0];
                if (C0 != 0B) goto <D.9160>; else goto <D.9161>;
                <D.9160>:
                D.8888 = _gm_.least_addr;
                D.9162 = D.8888 <= C0;
                D.9163 = (long int) D.9162;
                D.9164 = __builtin_expect (D.9163, 1);
                if (D.9164 != 0) goto <D.9165>; else goto <D.9166>;
                <D.9165>:
                R->child[0] = C0;
                C0->parent = R;
                goto <D.9167>;
                <D.9166>:
                abort ();
                <D.9167>:
                <D.9161>:
                C1 = TP->child[1];
                if (C1 != 0B) goto <D.9168>; else goto <D.9169>;
                <D.9168>:
                D.8888 = _gm_.least_addr;
                D.9170 = D.8888 <= C1;
                D.9171 = (long int) D.9170;
                D.9172 = __builtin_expect (D.9171, 1);
                if (D.9172 != 0) goto <D.9173>; else goto <D.9174>;
                <D.9173>:
                R->child[1] = C1;
                C1->parent = R;
                goto <D.9175>;
                <D.9174>:
                abort ();
                <D.9175>:
                <D.9169>:
              }
              goto <D.9176>;
              <D.9159>:
              abort ();
              <D.9176>:
              <D.9154>:
            }
            <D.9131>:
          }
        }
        <D.9108>:
        D.9037 = psize | 1;
        p->head = D.9037;
        D.9038 = p + psize;
        D.9038->prev_foot = psize;
        D.8919 = _gm_.dv;
        if (D.8919 == p) goto <D.9177>; else goto <D.9178>;
        <D.9177>:
        _gm_.dvsize = psize;
        goto postaction;
        <D.9178>:
      }
      goto <D.9179>;
      <D.9052>:
      D.9032 = next->head;
      D.9036 = D.9032 & 4294967294;
      next->head = D.9036;
      D.9037 = psize | 1;
      p->head = D.9037;
      D.9038 = p + psize;
      D.9038->prev_foot = psize;
      <D.9179>:
      D.9180 = psize >> 3;
      if (D.9180 <= 31) goto <D.9181>; else goto <D.9182>;
      <D.9181>:
      {
        bindex_t I;
        struct malloc_chunk * B;
        struct malloc_chunk * F;

        I = psize >> 3;
        D.9183 = I << 1;
        B = &_gm_.smallbins[D.9183];
        F = B;
        D.8927 = _gm_.smallmap;
        I.69 = (int) I;
        D.9185 = 1 << I.69;
        D.9186 = D.8927 & D.9185;
        if (D.9186 == 0) goto <D.9187>; else goto <D.9188>;
        <D.9187>:
        D.8927 = _gm_.smallmap;
        I.69 = (int) I;
        D.9185 = 1 << I.69;
        D.9189 = D.8927 | D.9185;
        _gm_.smallmap = D.9189;
        goto <D.9190>;
        <D.9188>:
        D.9191 = B->fd;
        D.8888 = _gm_.least_addr;
        D.9192 = D.9191 >= D.8888;
        D.9193 = (long int) D.9192;
        D.9194 = __builtin_expect (D.9193, 1);
        if (D.9194 != 0) goto <D.9195>; else goto <D.9196>;
        <D.9195>:
        F = B->fd;
        goto <D.9197>;
        <D.9196>:
        abort ();
        <D.9197>:
        <D.9190>:
        B->fd = p;
        F->bk = p;
        p->fd = F;
        p->bk = B;
      }
      goto <D.9198>;
      <D.9182>:
      {
        struct malloc_tree_chunk * TP;

        TP = p;
        {
          struct malloc_tree_chunk * * H;
          bindex_t I;

          {
            size_t X;

            X = psize >> 8;
            if (X == 0) goto <D.9199>; else goto <D.9200>;
            <D.9199>:
            I = 0;
            goto <D.9201>;
            <D.9200>:
            if (X > 65535) goto <D.9202>; else goto <D.9203>;
            <D.9202>:
            I = 31;
            goto <D.9204>;
            <D.9203>:
            {
              unsigned int Y;
              unsigned int N;
              unsigned int K;

              Y = X;
              D.9205 = Y + 4294967040;
              D.9206 = D.9205 >> 16;
              N = D.9206 & 8;
              N.70 = (int) N;
              Y = Y << N.70;
              D.9208 = Y + 4294963200;
              D.9209 = D.9208 >> 16;
              K = D.9209 & 4;
              N = N + K;
              K.71 = (int) K;
              Y = Y << K.71;
              D.9211 = Y + 4294950912;
              D.9212 = D.9211 >> 16;
              K = D.9212 & 2;
              K.72 = K;
              N = K.72 + N;
              K.71 = (int) K;
              Y = Y << K.71;
              D.9214 = Y >> 15;
              D.9215 = D.9214 - N;
              K = D.9215 + 14;
              D.9216 = K << 1;
              D.9217 = K + 7;
              D.9218 = (int) D.9217;
              D.9219 = psize >> D.9218;
              D.9220 = D.9219 & 1;
              I = D.9216 + D.9220;
            }
            <D.9204>:
            <D.9201>:
          }
          H = &_gm_.treebins[I];
          TP->index = I;
          TP->child[1] = 0B;
          D.9221 = TP->child[1];
          TP->child[0] = D.9221;
          D.8991 = _gm_.treemap;
          I.73 = (int) I;
          D.9223 = 1 << I.73;
          D.9224 = D.8991 & D.9223;
          if (D.9224 == 0) goto <D.9225>; else goto <D.9226>;
          <D.9225>:
          D.8991 = _gm_.treemap;
          I.73 = (int) I;
          D.9223 = 1 << I.73;
          D.9227 = D.8991 | D.9223;
          _gm_.treemap = D.9227;
          *H = TP;
          TP->parent = H;
          TP->bk = TP;
          D.9228 = TP->bk;
          TP->fd = D.9228;
          goto <D.9229>;
          <D.9226>:
          {
            struct malloc_tree_chunk * T;
            size_t K;

            T = *H;
            if (I != 31) goto <D.9231>; else goto <D.9232>;
            <D.9231>:
            D.9233 = I >> 1;
            D.9234 = 25 - D.9233;
            iftmp.74 = (int) D.9234;
            goto <D.9235>;
            <D.9232>:
            iftmp.74 = 0;
            <D.9235>:
            K = psize << iftmp.74;
            <D.7773>:
            D.9236 = T->head;
            D.9237 = D.9236 & 4294967292;
            if (D.9237 != psize) goto <D.9238>; else goto <D.9239>;
            <D.9238>:
            {
              struct malloc_tree_chunk * * C;

              D.9240 = K >> 31;
              C = &T->child[D.9240];
              K = K << 1;
              D.9241 = *C;
              if (D.9241 != 0B) goto <D.9242>; else goto <D.9243>;
              <D.9242>:
              T = *C;
              goto <D.9244>;
              <D.9243>:
              D.8888 = _gm_.least_addr;
              D.9245 = D.8888 <= C;
              D.9246 = (long int) D.9245;
              D.9247 = __builtin_expect (D.9246, 1);
              if (D.9247 != 0) goto <D.9248>; else goto <D.9249>;
              <D.9248>:
              *C = TP;
              TP->parent = T;
              TP->bk = TP;
              D.9228 = TP->bk;
              TP->fd = D.9228;
              goto <D.7771>;
              <D.9249>:
              abort ();
              <D.9244>:
            }
            goto <D.9250>;
            <D.9239>:
            {
              struct malloc_tree_chunk * F;

              F = T->fd;
              D.8888 = _gm_.least_addr;
              D.9252 = D.8888 <= T;
              D.9253 = (long int) D.9252;
              D.9254 = __builtin_expect (D.9253, 1);
              if (D.9254 != 0) goto <D.9255>; else goto <D.9251>;
              <D.9255>:
              D.8888 = _gm_.least_addr;
              D.9256 = D.8888 <= F;
              D.9257 = (long int) D.9256;
              D.9258 = __builtin_expect (D.9257, 1);
              if (D.9258 != 0) goto <D.9259>; else goto <D.9251>;
              <D.9259>:
              F->bk = TP;
              D.9260 = F->bk;
              T->fd = D.9260;
              TP->fd = F;
              TP->bk = T;
              TP->parent = 0B;
              goto <D.7771>;
              <D.9251>:
              abort ();
            }
            <D.9250>:
            goto <D.7773>;
            <D.7771>:
          }
          <D.9229>:
        }
      }
      <D.9198>:
      goto postaction;
      <D.9049>:
      <D.9043>:
    }
    <D.8900>:
    <D.8893>:
    erroraction:
    abort ();
    postaction:
    D.8885 = _gm_.mflags;
    D.8886 = D.8885 & 2;
    if (D.8886 != 0) goto <D.9261>; else goto <D.9262>;
    <D.9261>:
    pthread_mutex_unlock (&_gm_.mutex);
    <D.9262>:
    <D.8881>:
  }
  <D.8877>:
}


sys_trim (struct malloc_state * m, size_t pad)
{
  struct malloc_chunk * D.9265;
  unsigned int D.9268;
  unsigned int D.9271;
  unsigned int D.9272;
  unsigned int D.9273;
  unsigned int D.9274;
  unsigned int D.9275;
  unsigned int D.9276;
  unsigned int D.9277;
  unsigned int D.9280;
  unsigned int D.9283;
  int D.9286;
  char * D.9291;
  void * D.9292;
  void * D.9294;
  int D.9295;
  char * D.9301;
  _Bool D.9304;
  _Bool D.9305;
  _Bool D.9306;
  int old_br.75;
  int new_br.76;
  int D.9311;
  unsigned int D.9314;
  unsigned int D.9315;
  unsigned int D.9316;
  unsigned int D.9317;
  unsigned int D.9320;
  int D.9323;
  _Bool D.9324;
  size_t released;

  released = 0;
  if (pad <= 4294967231) goto <D.9263>; else goto <D.9264>;
  <D.9263>:
  D.9265 = m->top;
  if (D.9265 != 0B) goto <D.9266>; else goto <D.9267>;
  <D.9266>:
  pad = pad + 40;
  D.9268 = m->topsize;
  if (D.9268 > pad) goto <D.9269>; else goto <D.9270>;
  <D.9269>:
  {
    size_t unit;
    size_t extra;
    struct malloc_segment * sp;

    unit = mparams.granularity;
    D.9268 = m->topsize;
    D.9271 = D.9268 - pad;
    D.9272 = D.9271 + unit;
    D.9273 = D.9272 + 4294967295;
    D.9274 = D.9273 / unit;
    D.9275 = D.9274 + 4294967295;
    extra = D.9275 * unit;
    D.9265 = m->top;
    sp = segment_holding (m, D.9265);
    D.9276 = sp->sflags;
    D.9277 = D.9276 & 8;
    if (D.9277 == 0) goto <D.9278>; else goto <D.9279>;
    <D.9278>:
    D.9276 = sp->sflags;
    D.9280 = D.9276 & 1;
    if (D.9280 != 0) goto <D.9281>; else goto <D.9282>;
    <D.9281>:
    D.9283 = sp->size;
    if (D.9283 >= extra) goto <D.9284>; else goto <D.9285>;
    <D.9284>:
    D.9286 = has_segment_link (m, sp);
    if (D.9286 == 0) goto <D.9287>; else goto <D.9288>;
    <D.9287>:
    {
      size_t newsize;

      D.9283 = sp->size;
      newsize = D.9283 - extra;
      D.9291 = sp->base;
      D.9283 = sp->size;
      D.9292 = mremap (D.9291, D.9283, newsize, 0);
      if (D.9292 != 4294967295B) goto <D.9289>; else goto <D.9293>;
      <D.9293>:
      D.9291 = sp->base;
      D.9294 = D.9291 + newsize;
      D.9295 = munmap (D.9294, extra);
      if (D.9295 == 0) goto <D.9289>; else goto <D.9290>;
      <D.9289>:
      released = extra;
      <D.9290>:
    }
    <D.9288>:
    <D.9285>:
    goto <D.9296>;
    <D.9282>:
    if (0 != 0) goto <D.9297>; else goto <D.9298>;
    <D.9297>:
    if (extra > 2147483646) goto <D.9299>; else goto <D.9300>;
    <D.9299>:
    extra = 2147483648 - unit;
    <D.9300>:
    {
      char * old_br;

      old_br = 4294967295B;
      D.9291 = sp->base;
      D.9283 = sp->size;
      D.9301 = D.9291 + D.9283;
      if (D.9301 == old_br) goto <D.9302>; else goto <D.9303>;
      <D.9302>:
      {
        char * rel_br;
        char * new_br;

        rel_br = 4294967295B;
        new_br = 4294967295B;
        D.9304 = rel_br != 4294967295B;
        D.9305 = new_br < old_br;
        D.9306 = D.9304 & D.9305;
        if (D.9306 != 0) goto <D.9307>; else goto <D.9308>;
        <D.9307>:
        old_br.75 = (int) old_br;
        new_br.76 = (int) new_br;
        D.9311 = old_br.75 - new_br.76;
        released = (size_t) D.9311;
        <D.9308>:
      }
      <D.9303>:
    }
    <D.9298>:
    <D.9296>:
    <D.9279>:
    if (released != 0) goto <D.9312>; else goto <D.9313>;
    <D.9312>:
    D.9283 = sp->size;
    D.9314 = D.9283 - released;
    sp->size = D.9314;
    D.9315 = m->footprint;
    D.9316 = D.9315 - released;
    m->footprint = D.9316;
    D.9265 = m->top;
    D.9268 = m->topsize;
    D.9317 = D.9268 - released;
    init_top (m, D.9265, D.9317);
    <D.9313>:
  }
  <D.9270>:
  if (1 != 0) goto <D.9318>; else goto <D.9319>;
  <D.9318>:
  D.9320 = release_unused_segments (m);
  released = D.9320 + released;
  <D.9319>:
  if (released == 0) goto <D.9321>; else goto <D.9322>;
  <D.9321>:
  m->trim_check = 4294967295;
  <D.9322>:
  <D.9267>:
  <D.9264>:
  D.9324 = released != 0;
  D.9323 = (int) D.9324;
  return D.9323;
}


has_segment_link (struct malloc_state * m, struct malloc_segment * ss)
{
  char * D.9326;
  unsigned int D.9329;
  char * D.9330;
  int D.9333;
  struct malloc_segment * sp;

  sp = &m->seg;
  <D.7372>:
  D.9326 = ss->base;
  if (D.9326 <= sp) goto <D.9327>; else goto <D.9328>;
  <D.9327>:
  D.9326 = ss->base;
  D.9329 = ss->size;
  D.9330 = D.9326 + D.9329;
  if (D.9330 > sp) goto <D.9331>; else goto <D.9332>;
  <D.9331>:
  D.9333 = 1;
  return D.9333;
  <D.9332>:
  <D.9328>:
  sp = sp->next;
  if (sp == 0B) goto <D.9334>; else goto <D.9335>;
  <D.9334>:
  D.9333 = 0;
  return D.9333;
  <D.9335>:
  goto <D.7372>;
}


release_unused_segments (struct malloc_state * m)
{
  unsigned int D.9337;
  unsigned int D.9338;
  sizetype iftmp.77;
  void * D.9342;
  unsigned int D.9343;
  unsigned int D.9344;
  unsigned int D.9347;
  unsigned int D.9349;
  unsigned int D.9350;
  char * D.9353;
  sizetype D.9354;
  char * D.9355;
  struct malloc_chunk * D.9358;
  struct malloc_tree_chunk * D.9362;
  char * D.9365;
  _Bool D.9366;
  long int D.9367;
  long int D.9368;
  struct malloc_tree_chunk * D.9376;
  _Bool D.9378;
  long int D.9379;
  long int D.9380;
  unsigned int D.9386;
  struct malloc_tree_chunk * D.9387;
  unsigned int D.9392;
  int D.9393;
  unsigned int D.9394;
  unsigned int D.9395;
  unsigned int D.9396;
  _Bool D.9398;
  long int D.9399;
  long int D.9400;
  struct malloc_tree_chunk * D.9403;
  _Bool D.9410;
  long int D.9411;
  long int D.9412;
  _Bool D.9417;
  long int D.9418;
  long int D.9419;
  _Bool D.9425;
  long int D.9426;
  long int D.9427;
  int D.9432;
  unsigned int D.9435;
  unsigned int D.9436;
  unsigned int D.9444;
  unsigned int D.9445;
  int N.78;
  unsigned int D.9447;
  unsigned int D.9448;
  int K.79;
  unsigned int D.9450;
  unsigned int D.9451;
  unsigned int K.80;
  unsigned int D.9453;
  unsigned int D.9454;
  unsigned int D.9455;
  unsigned int D.9456;
  int D.9457;
  unsigned int D.9458;
  unsigned int D.9459;
  struct malloc_tree_chunk * D.9460;
  int I.81;
  unsigned int D.9462;
  unsigned int D.9463;
  unsigned int D.9466;
  int iftmp.82;
  unsigned int D.9471;
  unsigned int D.9472;
  unsigned int D.9474;
  unsigned int D.9475;
  unsigned int D.9478;
  struct malloc_tree_chunk * D.9479;
  _Bool D.9483;
  long int D.9484;
  long int D.9485;
  _Bool D.9490;
  long int D.9491;
  long int D.9492;
  _Bool D.9494;
  long int D.9495;
  long int D.9496;
  struct malloc_tree_chunk * D.9498;
  size_t D.9499;
  size_t released;
  struct malloc_segment * pred;
  struct malloc_segment * sp;

  released = 0;
  pred = &m->seg;
  sp = pred->next;
  goto <D.7555>;
  <D.7554>:
  {
    char * base;
    size_t size;
    struct malloc_segment * next;

    base = sp->base;
    size = sp->size;
    next = sp->next;
    D.9337 = BIT_FIELD_REF <*sp, 32, 96>;
    D.9338 = D.9337 & 9;
    if (D.9338 == 1) goto <D.9339>; else goto <D.9340>;
    <D.9339>:
    {
      struct malloc_chunk * p;
      size_t psize;

      D.9342 = base + 8;
      D.9343 = (unsigned int) D.9342;
      D.9344 = D.9343 & 7;
      if (D.9344 != 0) goto <D.9345>; else goto <D.9346>;
      <D.9345>:
      D.9342 = base + 8;
      D.9343 = (unsigned int) D.9342;
      D.9347 = -D.9343;
      iftmp.77 = D.9347 & 7;
      goto <D.9348>;
      <D.9346>:
      iftmp.77 = 0;
      <D.9348>:
      p = base + iftmp.77;
      D.9349 = p->head;
      psize = D.9349 & 4294967292;
      D.9349 = p->head;
      D.9350 = D.9349 & 2;
      if (D.9350 == 0) goto <D.9351>; else goto <D.9352>;
      <D.9351>:
      D.9353 = p + psize;
      D.9354 = size + 4294967256;
      D.9355 = base + D.9354;
      if (D.9353 >= D.9355) goto <D.9356>; else goto <D.9357>;
      <D.9356>:
      {
        struct malloc_tree_chunk * tp;

        tp = p;
        D.9358 = m->dv;
        if (D.9358 == p) goto <D.9359>; else goto <D.9360>;
        <D.9359>:
        m->dv = 0B;
        m->dvsize = 0;
        goto <D.9361>;
        <D.9360>:
        {
          struct malloc_tree_chunk * XP;
          struct malloc_tree_chunk * R;

          XP = tp->parent;
          D.9362 = tp->bk;
          if (D.9362 != tp) goto <D.9363>; else goto <D.9364>;
          <D.9363>:
          {
            struct malloc_tree_chunk * F;

            F = tp->fd;
            R = tp->bk;
            D.9365 = m->least_addr;
            D.9366 = D.9365 <= F;
            D.9367 = (long int) D.9366;
            D.9368 = __builtin_expect (D.9367, 1);
            if (D.9368 != 0) goto <D.9369>; else goto <D.9370>;
            <D.9369>:
            F->bk = R;
            R->fd = F;
            goto <D.9371>;
            <D.9370>:
            abort ();
            <D.9371>:
          }
          goto <D.9372>;
          <D.9364>:
          {
            struct malloc_tree_chunk * * RP;

            RP = &tp->child[1];
            R = *RP;
            if (R != 0B) goto <D.9373>; else goto <D.9375>;
            <D.9375>:
            RP = &tp->child[0];
            R = *RP;
            if (R != 0B) goto <D.9373>; else goto <D.9374>;
            <D.9373>:
            {
              struct malloc_tree_chunk * * CP;

              goto <D.7537>;
              <D.7536>:
              RP = CP;
              R = *RP;
              <D.7537>:
              CP = &R->child[1];
              D.9376 = *CP;
              if (D.9376 != 0B) goto <D.7536>; else goto <D.9377>;
              <D.9377>:
              CP = &R->child[0];
              D.9376 = *CP;
              if (D.9376 != 0B) goto <D.7536>; else goto <D.7538>;
              <D.7538>:
              D.9365 = m->least_addr;
              D.9378 = D.9365 <= RP;
              D.9379 = (long int) D.9378;
              D.9380 = __builtin_expect (D.9379, 1);
              if (D.9380 != 0) goto <D.9381>; else goto <D.9382>;
              <D.9381>:
              *RP = 0B;
              goto <D.9383>;
              <D.9382>:
              abort ();
              <D.9383>:
            }
            <D.9374>:
          }
          <D.9372>:
          if (XP != 0B) goto <D.9384>; else goto <D.9385>;
          <D.9384>:
          {
            struct malloc_tree_chunk * * H;

            D.9386 = tp->index;
            H = &m->treebins[D.9386];
            D.9387 = *H;
            if (D.9387 == tp) goto <D.9388>; else goto <D.9389>;
            <D.9388>:
            *H = R;
            D.9387 = *H;
            if (D.9387 == 0B) goto <D.9390>; else goto <D.9391>;
            <D.9390>:
            D.9392 = m->treemap;
            D.9386 = tp->index;
            D.9393 = (int) D.9386;
            D.9394 = 1 << D.9393;
            D.9395 = ~D.9394;
            D.9396 = D.9392 & D.9395;
            m->treemap = D.9396;
            <D.9391>:
            goto <D.9397>;
            <D.9389>:
            D.9365 = m->least_addr;
            D.9398 = D.9365 <= XP;
            D.9399 = (long int) D.9398;
            D.9400 = __builtin_expect (D.9399, 1);
            if (D.9400 != 0) goto <D.9401>; else goto <D.9402>;
            <D.9401>:
            D.9403 = XP->child[0];
            if (D.9403 == tp) goto <D.9404>; else goto <D.9405>;
            <D.9404>:
            XP->child[0] = R;
            goto <D.9406>;
            <D.9405>:
            XP->child[1] = R;
            <D.9406>:
            goto <D.9407>;
            <D.9402>:
            abort ();
            <D.9407>:
            <D.9397>:
            if (R != 0B) goto <D.9408>; else goto <D.9409>;
            <D.9408>:
            D.9365 = m->least_addr;
            D.9410 = D.9365 <= R;
            D.9411 = (long int) D.9410;
            D.9412 = __builtin_expect (D.9411, 1);
            if (D.9412 != 0) goto <D.9413>; else goto <D.9414>;
            <D.9413>:
            {
              struct malloc_tree_chunk * C0;
              struct malloc_tree_chunk * C1;

              R->parent = XP;
              C0 = tp->child[0];
              if (C0 != 0B) goto <D.9415>; else goto <D.9416>;
              <D.9415>:
              D.9365 = m->least_addr;
              D.9417 = D.9365 <= C0;
              D.9418 = (long int) D.9417;
              D.9419 = __builtin_expect (D.9418, 1);
              if (D.9419 != 0) goto <D.9420>; else goto <D.9421>;
              <D.9420>:
              R->child[0] = C0;
              C0->parent = R;
              goto <D.9422>;
              <D.9421>:
              abort ();
              <D.9422>:
              <D.9416>:
              C1 = tp->child[1];
              if (C1 != 0B) goto <D.9423>; else goto <D.9424>;
              <D.9423>:
              D.9365 = m->least_addr;
              D.9425 = D.9365 <= C1;
              D.9426 = (long int) D.9425;
              D.9427 = __builtin_expect (D.9426, 1);
              if (D.9427 != 0) goto <D.9428>; else goto <D.9429>;
              <D.9428>:
              R->child[1] = C1;
              C1->parent = R;
              goto <D.9430>;
              <D.9429>:
              abort ();
              <D.9430>:
              <D.9424>:
            }
            goto <D.9431>;
            <D.9414>:
            abort ();
            <D.9431>:
            <D.9409>:
          }
          <D.9385>:
        }
        <D.9361>:
        D.9432 = munmap (base, size);
        if (D.9432 == 0) goto <D.9433>; else goto <D.9434>;
        <D.9433>:
        released = released + size;
        D.9435 = m->footprint;
        D.9436 = D.9435 - size;
        m->footprint = D.9436;
        sp = pred;
        sp->next = next;
        goto <D.9437>;
        <D.9434>:
        {
          struct malloc_tree_chunk * * H;
          bindex_t I;

          {
            size_t X;

            X = psize >> 8;
            if (X == 0) goto <D.9438>; else goto <D.9439>;
            <D.9438>:
            I = 0;
            goto <D.9440>;
            <D.9439>:
            if (X > 65535) goto <D.9441>; else goto <D.9442>;
            <D.9441>:
            I = 31;
            goto <D.9443>;
            <D.9442>:
            {
              unsigned int Y;
              unsigned int N;
              unsigned int K;

              Y = X;
              D.9444 = Y + 4294967040;
              D.9445 = D.9444 >> 16;
              N = D.9445 & 8;
              N.78 = (int) N;
              Y = Y << N.78;
              D.9447 = Y + 4294963200;
              D.9448 = D.9447 >> 16;
              K = D.9448 & 4;
              N = N + K;
              K.79 = (int) K;
              Y = Y << K.79;
              D.9450 = Y + 4294950912;
              D.9451 = D.9450 >> 16;
              K = D.9451 & 2;
              K.80 = K;
              N = K.80 + N;
              K.79 = (int) K;
              Y = Y << K.79;
              D.9453 = Y >> 15;
              D.9454 = D.9453 - N;
              K = D.9454 + 14;
              D.9455 = K << 1;
              D.9456 = K + 7;
              D.9457 = (int) D.9456;
              D.9458 = psize >> D.9457;
              D.9459 = D.9458 & 1;
              I = D.9455 + D.9459;
            }
            <D.9443>:
            <D.9440>:
          }
          H = &m->treebins[I];
          tp->index = I;
          tp->child[1] = 0B;
          D.9460 = tp->child[1];
          tp->child[0] = D.9460;
          D.9392 = m->treemap;
          I.81 = (int) I;
          D.9462 = 1 << I.81;
          D.9463 = D.9392 & D.9462;
          if (D.9463 == 0) goto <D.9464>; else goto <D.9465>;
          <D.9464>:
          D.9392 = m->treemap;
          I.81 = (int) I;
          D.9462 = 1 << I.81;
          D.9466 = D.9392 | D.9462;
          m->treemap = D.9466;
          *H = tp;
          tp->parent = H;
          tp->bk = tp;
          D.9362 = tp->bk;
          tp->fd = D.9362;
          goto <D.9467>;
          <D.9465>:
          {
            struct malloc_tree_chunk * T;
            size_t K;

            T = *H;
            if (I != 31) goto <D.9469>; else goto <D.9470>;
            <D.9469>:
            D.9471 = I >> 1;
            D.9472 = 25 - D.9471;
            iftmp.82 = (int) D.9472;
            goto <D.9473>;
            <D.9470>:
            iftmp.82 = 0;
            <D.9473>:
            K = psize << iftmp.82;
            <D.7553>:
            D.9474 = T->head;
            D.9475 = D.9474 & 4294967292;
            if (D.9475 != psize) goto <D.9476>; else goto <D.9477>;
            <D.9476>:
            {
              struct malloc_tree_chunk * * C;

              D.9478 = K >> 31;
              C = &T->child[D.9478];
              K = K << 1;
              D.9479 = *C;
              if (D.9479 != 0B) goto <D.9480>; else goto <D.9481>;
              <D.9480>:
              T = *C;
              goto <D.9482>;
              <D.9481>:
              D.9365 = m->least_addr;
              D.9483 = D.9365 <= C;
              D.9484 = (long int) D.9483;
              D.9485 = __builtin_expect (D.9484, 1);
              if (D.9485 != 0) goto <D.9486>; else goto <D.9487>;
              <D.9486>:
              *C = tp;
              tp->parent = T;
              tp->bk = tp;
              D.9362 = tp->bk;
              tp->fd = D.9362;
              goto <D.7551>;
              <D.9487>:
              abort ();
              <D.9482>:
            }
            goto <D.9488>;
            <D.9477>:
            {
              struct malloc_tree_chunk * F;

              F = T->fd;
              D.9365 = m->least_addr;
              D.9490 = D.9365 <= T;
              D.9491 = (long int) D.9490;
              D.9492 = __builtin_expect (D.9491, 1);
              if (D.9492 != 0) goto <D.9493>; else goto <D.9489>;
              <D.9493>:
              D.9365 = m->least_addr;
              D.9494 = D.9365 <= F;
              D.9495 = (long int) D.9494;
              D.9496 = __builtin_expect (D.9495, 1);
              if (D.9496 != 0) goto <D.9497>; else goto <D.9489>;
              <D.9497>:
              F->bk = tp;
              D.9498 = F->bk;
              T->fd = D.9498;
              tp->fd = F;
              tp->bk = T;
              tp->parent = 0B;
              goto <D.7551>;
              <D.9489>:
              abort ();
            }
            <D.9488>:
            goto <D.7553>;
            <D.7551>:
          }
          <D.9467>:
        }
        <D.9437>:
      }
      <D.9357>:
      <D.9352>:
    }
    <D.9340>:
    pred = sp;
    sp = next;
  }
  <D.7555>:
  if (sp != 0B) goto <D.7554>; else goto <D.7556>;
  <D.7556>:
  D.9499 = released;
  return D.9499;
}


dlmemalign (size_t alignment, size_t bytes)
{
  void * D.9501;

  D.9501 = internal_memalign (&_gm_, alignment, bytes);
  return D.9501;
}


internal_memalign (struct malloc_state * m, size_t alignment, size_t bytes)
{
  void * D.9505;
  unsigned int D.9508;
  unsigned int D.9509;
  unsigned int D.9512;
  int * D.9517;
  unsigned int iftmp.83;
  unsigned int D.9522;
  unsigned int D.9524;
  unsigned int D.9530;
  int D.9532;
  unsigned int D.9533;
  unsigned int D.9534;
  union pthread_mutex_t * D.9535;
  int D.9536;
  unsigned int mem.84;
  unsigned int D.9540;
  sizetype D.9543;
  char * D.9544;
  unsigned int D.9545;
  unsigned int D.9546;
  unsigned int D.9547;
  sizetype D.9548;
  char * iftmp.85;
  int br.86;
  int p.87;
  int D.9552;
  unsigned int D.9553;
  int pos.88;
  int D.9558;
  unsigned int D.9559;
  unsigned int D.9560;
  unsigned int D.9563;
  unsigned int D.9565;
  unsigned int D.9566;
  unsigned int D.9568;
  unsigned int D.9569;
  unsigned int D.9570;
  unsigned int D.9571;
  unsigned int D.9572;
  unsigned int D.9573;
  struct malloc_chunk * D.9574;
  unsigned int D.9575;
  unsigned int D.9576;
  unsigned int D.9577;
  unsigned int D.9578;
  struct malloc_chunk * D.9579;
  unsigned int D.9580;
  unsigned int D.9581;
  unsigned int D.9585;
  unsigned int D.9588;
  unsigned int D.9589;
  struct malloc_chunk * D.9590;
  unsigned int D.9591;
  unsigned int D.9592;
  unsigned int D.9593;
  unsigned int D.9594;
  unsigned int D.9595;
  unsigned int D.9596;
  struct malloc_chunk * D.9597;
  unsigned int D.9598;
  unsigned int D.9599;

  if (alignment <= 8) goto <D.9503>; else goto <D.9504>;
  <D.9503>:
  D.9505 = dlmalloc (bytes);
  return D.9505;
  <D.9504>:
  if (alignment <= 15) goto <D.9506>; else goto <D.9507>;
  <D.9506>:
  alignment = 16;
  <D.9507>:
  D.9508 = alignment + 4294967295;
  D.9509 = D.9508 & alignment;
  if (D.9509 != 0) goto <D.9510>; else goto <D.9511>;
  <D.9510>:
  {
    size_t a;

    a = 16;
    goto <D.7665>;
    <D.7664>:
    a = a << 1;
    <D.7665>:
    if (a < alignment) goto <D.7664>; else goto <D.7666>;
    <D.7666>:
    alignment = a;
  }
  <D.9511>:
  D.9512 = 4294967232 - alignment;
  if (D.9512 <= bytes) goto <D.9513>; else goto <D.9514>;
  <D.9513>:
  if (m != 0B) goto <D.9515>; else goto <D.9516>;
  <D.9515>:
  D.9517 = __errno_location ();
  *D.9517 = 12;
  <D.9516>:
  goto <D.9518>;
  <D.9514>:
  {
    size_t nb;
    size_t req;
    char * mem;

    if (bytes > 10) goto <D.9520>; else goto <D.9521>;
    <D.9520>:
    D.9522 = bytes + 11;
    iftmp.83 = D.9522 & 4294967288;
    goto <D.9523>;
    <D.9521>:
    iftmp.83 = 16;
    <D.9523>:
    nb = iftmp.83;
    D.9524 = nb + alignment;
    req = D.9524 + 12;
    mem = dlmalloc (req);
    if (mem != 0B) goto <D.9525>; else goto <D.9526>;
    <D.9525>:
    {
      void * leader;
      void * trailer;
      struct malloc_chunk * p;

      leader = 0B;
      trailer = 0B;
      p = mem + 4294967288;
      D.9530 = mparams.page_size;
      if (D.9530 == 0) goto <D.9531>; else goto <D.9527>;
      <D.9531>:
      D.9532 = init_mparams ();
      if (D.9532 != 0) goto <D.9528>; else goto <D.9527>;
      <D.9527>:
      D.9533 = m->mflags;
      D.9534 = D.9533 & 2;
      if (D.9534 != 0) goto <D.9528>; else goto <D.9529>;
      <D.9528>:
      D.9535 = &m->mutex;
      D.9536 = pthread_mutex_lock (D.9535);
      if (D.9536 != 0) goto <D.9537>; else goto <D.9538>;
      <D.9537>:
      D.9505 = 0B;
      return D.9505;
      <D.9538>:
      <D.9529>:
      mem.84 = (unsigned int) mem;
      D.9540 = mem.84 % alignment;
      if (D.9540 != 0) goto <D.9541>; else goto <D.9542>;
      <D.9541>:
      {
        char * br;
        char * pos;
        struct malloc_chunk * newp;
        size_t leadsize;
        size_t newsize;

        D.9543 = alignment + 4294967295;
        D.9544 = mem + D.9543;
        D.9545 = (unsigned int) D.9544;
        D.9546 = -alignment;
        D.9547 = D.9545 & D.9546;
        D.9548 = D.9547 + 4294967288;
        br = (char *) D.9548;
        br.86 = (int) br;
        p.87 = (int) p;
        D.9552 = br.86 - p.87;
        D.9553 = (unsigned int) D.9552;
        if (D.9553 <= 15) goto <D.9554>; else goto <D.9555>;
        <D.9554>:
        iftmp.85 = br + alignment;
        goto <D.9556>;
        <D.9555>:
        iftmp.85 = br;
        <D.9556>:
        pos = iftmp.85;
        newp = pos;
        pos.88 = (int) pos;
        p.87 = (int) p;
        D.9558 = pos.88 - p.87;
        leadsize = (size_t) D.9558;
        D.9559 = p->head;
        D.9560 = D.9559 & 4294967292;
        newsize = D.9560 - leadsize;
        D.9559 = p->head;
        D.9563 = D.9559 & 1;
        if (D.9563 == 0) goto <D.9564>; else goto <D.9561>;
        <D.9564>:
        D.9565 = p->prev_foot;
        D.9566 = D.9565 & 1;
        if (D.9566 != 0) goto <D.9567>; else goto <D.9561>;
        <D.9567>:
        D.9565 = p->prev_foot;
        D.9568 = D.9565 + leadsize;
        newp->prev_foot = D.9568;
        D.9569 = newsize | 2;
        newp->head = D.9569;
        goto <D.9562>;
        <D.9561>:
        D.9570 = newp->head;
        D.9571 = D.9570 & 1;
        D.9572 = D.9571 | newsize;
        D.9573 = D.9572 | 2;
        newp->head = D.9573;
        D.9574 = newp + newsize;
        D.9574 = newp + newsize;
        D.9575 = D.9574->head;
        D.9576 = D.9575 | 1;
        D.9574->head = D.9576;
        D.9559 = p->head;
        D.9563 = D.9559 & 1;
        D.9577 = D.9563 | leadsize;
        D.9578 = D.9577 | 2;
        p->head = D.9578;
        D.9579 = p + leadsize;
        D.9579 = p + leadsize;
        D.9580 = D.9579->head;
        D.9581 = D.9580 | 1;
        D.9579->head = D.9581;
        leader = p + 8;
        <D.9562>:
        p = newp;
      }
      <D.9542>:
      D.9559 = p->head;
      D.9563 = D.9559 & 1;
      if (D.9563 != 0) goto <D.9582>; else goto <D.9584>;
      <D.9584>:
      D.9565 = p->prev_foot;
      D.9566 = D.9565 & 1;
      if (D.9566 == 0) goto <D.9582>; else goto <D.9583>;
      <D.9582>:
      {
        size_t size;

        D.9559 = p->head;
        size = D.9559 & 4294967292;
        D.9585 = nb + 16;
        if (D.9585 < size) goto <D.9586>; else goto <D.9587>;
        <D.9586>:
        {
          size_t remainder_size;
          struct malloc_chunk * remainder;

          remainder_size = size - nb;
          remainder = p + nb;
          D.9559 = p->head;
          D.9563 = D.9559 & 1;
          D.9588 = D.9563 | nb;
          D.9589 = D.9588 | 2;
          p->head = D.9589;
          D.9590 = p + nb;
          D.9590 = p + nb;
          D.9591 = D.9590->head;
          D.9592 = D.9591 | 1;
          D.9590->head = D.9592;
          D.9593 = remainder->head;
          D.9594 = D.9593 & 1;
          D.9595 = D.9594 | remainder_size;
          D.9596 = D.9595 | 2;
          remainder->head = D.9596;
          D.9597 = remainder + remainder_size;
          D.9597 = remainder + remainder_size;
          D.9598 = D.9597->head;
          D.9599 = D.9598 | 1;
          D.9597->head = D.9599;
          trailer = remainder + 8;
        }
        <D.9587>:
      }
      <D.9583>:
      D.9533 = m->mflags;
      D.9534 = D.9533 & 2;
      if (D.9534 != 0) goto <D.9600>; else goto <D.9601>;
      <D.9600>:
      D.9535 = &m->mutex;
      pthread_mutex_unlock (D.9535);
      <D.9601>:
      if (leader != 0B) goto <D.9602>; else goto <D.9603>;
      <D.9602>:
      dlfree (leader);
      <D.9603>:
      if (trailer != 0B) goto <D.9604>; else goto <D.9605>;
      <D.9604>:
      dlfree (trailer);
      <D.9605>:
      D.9505 = p + 8;
      return D.9505;
    }
    <D.9526>:
  }
  <D.9518>:
  D.9505 = 0B;
  return D.9505;
}