dlmalloc (size_t bytes)
{
  long unsigned int D.5740;
  int D.5742;
  unsigned int D.5743;
  unsigned int D.5744;
  int D.5745;
  long unsigned int iftmp.0;
  long unsigned int D.5751;
  long unsigned int D.5753;
  unsigned int D.5754;
  unsigned int D.5755;
  unsigned int D.5758;
  _Bool D.5759;
  unsigned int D.5760;
  unsigned int D.5761;
  unsigned int D.5764;
  unsigned int D.5765;
  unsigned int D.5766;
  char * D.5768;
  _Bool D.5769;
  long int D.5770;
  long int D.5771;
  unsigned int D.5775;
  unsigned int D.5776;
  long unsigned int D.5777;
  sizetype D.5778;
  struct malloc_chunk * D.5779;
  long unsigned int D.5780;
  long unsigned int D.5781;
  long unsigned int D.5782;
  unsigned int D.5787;
  unsigned int D.5788;
  unsigned int D.5789;
  unsigned int D.5790;
  unsigned int D.5791;
  unsigned int D.5792;
  unsigned int D.5793;
  unsigned int K.1;
  unsigned int D.5795;
  unsigned int K.2;
  unsigned int D.5797;
  unsigned int K.3;
  unsigned int K.4;
  unsigned int D.5800;
  unsigned int D.5803;
  unsigned int D.5804;
  unsigned int D.5805;
  _Bool D.5807;
  long int D.5808;
  long int D.5809;
  unsigned int D.5813;
  long unsigned int D.5814;
  unsigned int D.5817;
  long unsigned int D.5818;
  sizetype D.5819;
  struct malloc_chunk * D.5820;
  long unsigned int D.5821;
  long unsigned int D.5822;
  long unsigned int D.5824;
  long unsigned int D.5825;
  struct malloc_chunk * D.5826;
  long unsigned int D.5829;
  unsigned int D.5830;
  unsigned int D.5831;
  unsigned int D.5832;
  unsigned int D.5835;
  struct malloc_chunk * D.5837;
  _Bool D.5838;
  long int D.5839;
  long int D.5840;
  unsigned int D.5844;
  struct malloc_chunk * D.5859;
  long unsigned int D.5860;
  struct malloc_chunk * D.5861;
  long unsigned int D.5863;
  struct malloc_chunk * D.5864;
  long unsigned int D.5865;
  long unsigned int D.5866;
  long unsigned int D.5867;
  long unsigned int D.5870;
  struct malloc_chunk * D.5871;
  long unsigned int D.5872;
  void * D.5875;
  void postaction = <<< error >>>;

  D.5740 = mparams.page_size;
  if (D.5740 != 0) goto <D.5736>; else goto <D.5741>;
  <D.5741>:
  D.5742 = init_mparams ();
  if (D.5742 == 0) goto <D.5736>; else goto <D.5737>;
  <D.5736>:
  D.5743 = _gm_.mflags;
  D.5744 = D.5743 & 2;
  if (D.5744 == 0) goto <D.5738>; else goto <D.5737>;
  <D.5737>:
  D.5745 = pthread_mutex_lock (&_gm_.mutex);
  if (D.5745 == 0) goto <D.5738>; else goto <D.5739>;
  <D.5738>:
  {
    void * mem;
    size_t nb;

    if (bytes <= 240) goto <D.5746>; else goto <D.5747>;
    <D.5746>:
    {
      bindex_t idx;
      binmap_t smallbits;

      if (bytes > 22) goto <D.5749>; else goto <D.5750>;
      <D.5749>:
      D.5751 = bytes + 15;
      iftmp.0 = D.5751 & 18446744073709551608;
      goto <D.5752>;
      <D.5750>:
      iftmp.0 = 32;
      <D.5752>:
      nb = iftmp.0;
      D.5753 = nb >> 3;
      idx = (bindex_t) D.5753;
      D.5754 = _gm_.smallmap;
      smallbits = D.5754 >> idx;
      D.5755 = smallbits & 3;
      if (D.5755 != 0) goto <D.5756>; else goto <D.5757>;
      <D.5756>:
      {
        struct malloc_chunk * b;
        struct malloc_chunk * p;

        D.5758 = smallbits & 1;
        D.5759 = D.5758 == 0;
        D.5760 = (unsigned int) D.5759;
        idx = D.5760 + idx;
        D.5761 = idx << 1;
        b = &_gm_.smallbins[D.5761];
        p = b->fd;
        {
          struct malloc_chunk * F;

          F = p->fd;
          if (b == F) goto <D.5762>; else goto <D.5763>;
          <D.5762>:
          D.5754 = _gm_.smallmap;
          D.5764 = 1 << idx;
          D.5765 = ~D.5764;
          D.5766 = D.5754 & D.5765;
          _gm_.smallmap = D.5766;
          goto <D.5767>;
          <D.5763>:
          D.5768 = _gm_.least_addr;
          D.5769 = D.5768 <= F;
          D.5770 = (long int) D.5769;
          D.5771 = __builtin_expect (D.5770, 1);
          if (D.5771 != 0) goto <D.5772>; else goto <D.5773>;
          <D.5772>:
          b->fd = F;
          F->bk = b;
          goto <D.5774>;
          <D.5773>:
          abort ();
          <D.5774>:
          <D.5767>:
        }
        D.5775 = idx << 3;
        D.5776 = D.5775 | 3;
        D.5777 = (long unsigned int) D.5776;
        p->head = D.5777;
        D.5775 = idx << 3;
        D.5778 = (sizetype) D.5775;
        D.5779 = p + D.5778;
        D.5775 = idx << 3;
        D.5778 = (sizetype) D.5775;
        D.5779 = p + D.5778;
        D.5780 = D.5779->head;
        D.5781 = D.5780 | 1;
        D.5779->head = D.5781;
        mem = p + 16;
        goto postaction;
      }
      <D.5757>:
      D.5782 = _gm_.dvsize;
      if (D.5782 < nb) goto <D.5783>; else goto <D.5784>;
      <D.5783>:
      if (smallbits != 0) goto <D.5785>; else goto <D.5786>;
      <D.5785>:
      {
        struct malloc_chunk * b;
        struct malloc_chunk * p;
        struct malloc_chunk * r;
        size_t rsize;
        bindex_t i;
        binmap_t leftbits;
        binmap_t leastbit;

        D.5787 = smallbits << idx;
        D.5764 = 1 << idx;
        D.5788 = D.5764 << 1;
        D.5764 = 1 << idx;
        D.5788 = D.5764 << 1;
        D.5789 = -D.5788;
        D.5790 = D.5788 | D.5789;
        leftbits = D.5787 & D.5790;
        D.5791 = -leftbits;
        leastbit = D.5791 & leftbits;
        {
          unsigned int Y;
          unsigned int K;
          unsigned int N;

          Y = leastbit + 4294967295;
          D.5792 = Y >> 12;
          K = D.5792 & 16;
          N = K;
          Y = Y >> K;
          D.5793 = Y >> 5;
          K = D.5793 & 8;
          K.1 = K;
          N = K.1 + N;
          Y = Y >> K;
          D.5795 = Y >> 2;
          K = D.5795 & 4;
          K.2 = K;
          N = K.2 + N;
          Y = Y >> K;
          D.5797 = Y >> 1;
          K = D.5797 & 2;
          K.3 = K;
          N = K.3 + N;
          Y = Y >> K;
          D.5797 = Y >> 1;
          K = D.5797 & 1;
          K.4 = K;
          N = K.4 + N;
          Y = Y >> K;
          i = N + Y;
        }
        D.5800 = i << 1;
        b = &_gm_.smallbins[D.5800];
        p = b->fd;
        {
          struct malloc_chunk * F;

          F = p->fd;
          if (b == F) goto <D.5801>; else goto <D.5802>;
          <D.5801>:
          D.5754 = _gm_.smallmap;
          D.5803 = 1 << i;
          D.5804 = ~D.5803;
          D.5805 = D.5754 & D.5804;
          _gm_.smallmap = D.5805;
          goto <D.5806>;
          <D.5802>:
          D.5768 = _gm_.least_addr;
          D.5807 = D.5768 <= F;
          D.5808 = (long int) D.5807;
          D.5809 = __builtin_expect (D.5808, 1);
          if (D.5809 != 0) goto <D.5810>; else goto <D.5811>;
          <D.5810>:
          b->fd = F;
          F->bk = b;
          goto <D.5812>;
          <D.5811>:
          abort ();
          <D.5812>:
          <D.5806>:
        }
        D.5813 = i << 3;
        D.5814 = (long unsigned int) D.5813;
        rsize = D.5814 - nb;
        if (rsize <= 31) goto <D.5815>; else goto <D.5816>;
        <D.5815>:
        D.5813 = i << 3;
        D.5817 = D.5813 | 3;
        D.5818 = (long unsigned int) D.5817;
        p->head = D.5818;
        D.5813 = i << 3;
        D.5819 = (sizetype) D.5813;
        D.5820 = p + D.5819;
        D.5813 = i << 3;
        D.5819 = (sizetype) D.5813;
        D.5820 = p + D.5819;
        D.5821 = D.5820->head;
        D.5822 = D.5821 | 1;
        D.5820->head = D.5822;
        goto <D.5823>;
        <D.5816>:
        D.5824 = nb | 3;
        p->head = D.5824;
        r = p + nb;
        D.5825 = rsize | 1;
        r->head = D.5825;
        D.5826 = r + rsize;
        D.5826->prev_foot = rsize;
        {
          size_t DVS;

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

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

              D.5829 = DVS >> 3;
              I = (bindex_t) D.5829;
              D.5830 = I << 1;
              B = &_gm_.smallbins[D.5830];
              F = B;
              D.5754 = _gm_.smallmap;
              D.5831 = 1 << I;
              D.5832 = D.5754 & D.5831;
              if (D.5832 == 0) goto <D.5833>; else goto <D.5834>;
              <D.5833>:
              D.5754 = _gm_.smallmap;
              D.5831 = 1 << I;
              D.5835 = D.5754 | D.5831;
              _gm_.smallmap = D.5835;
              goto <D.5836>;
              <D.5834>:
              D.5837 = B->fd;
              D.5768 = _gm_.least_addr;
              D.5838 = D.5837 >= D.5768;
              D.5839 = (long int) D.5838;
              D.5840 = __builtin_expect (D.5839, 1);
              if (D.5840 != 0) goto <D.5841>; else goto <D.5842>;
              <D.5841>:
              F = B->fd;
              goto <D.5843>;
              <D.5842>:
              abort ();
              <D.5843>:
              <D.5836>:
              B->fd = DV;
              F->bk = DV;
              DV->fd = F;
              DV->bk = B;
            }
          }
          <D.5828>:
          _gm_.dvsize = rsize;
          _gm_.dv = r;
        }
        <D.5823>:
        mem = p + 16;
        goto postaction;
      }
      <D.5786>:
      D.5844 = _gm_.treemap;
      if (D.5844 != 0) goto <D.5845>; else goto <D.5846>;
      <D.5845>:
      mem = tmalloc_small (&_gm_, nb);
      if (mem != 0B) goto postaction; else goto <D.5847>;
      <D.5847>:
      <D.5846>:
      <D.5784>:
    }
    goto <D.5848>;
    <D.5747>:
    if (bytes > 18446744073709551487) goto <D.5849>; else goto <D.5850>;
    <D.5849>:
    nb = 18446744073709551615;
    goto <D.5851>;
    <D.5850>:
    D.5751 = bytes + 15;
    nb = D.5751 & 18446744073709551608;
    D.5844 = _gm_.treemap;
    if (D.5844 != 0) goto <D.5852>; else goto <D.5853>;
    <D.5852>:
    mem = tmalloc_large (&_gm_, nb);
    if (mem != 0B) goto postaction; else goto <D.5854>;
    <D.5854>:
    <D.5853>:
    <D.5851>:
    <D.5848>:
    D.5782 = _gm_.dvsize;
    if (D.5782 >= nb) goto <D.5855>; else goto <D.5856>;
    <D.5855>:
    {
      size_t rsize;
      struct malloc_chunk * p;

      D.5782 = _gm_.dvsize;
      rsize = D.5782 - nb;
      p = _gm_.dv;
      if (rsize > 31) goto <D.5857>; else goto <D.5858>;
      <D.5857>:
      {
        struct malloc_chunk * r;

        D.5859 = p + nb;
        _gm_.dv = D.5859;
        r = _gm_.dv;
        _gm_.dvsize = rsize;
        D.5860 = rsize | 1;
        r->head = D.5860;
        D.5861 = r + rsize;
        D.5861->prev_foot = rsize;
        D.5824 = nb | 3;
        p->head = D.5824;
      }
      goto <D.5862>;
      <D.5858>:
      {
        size_t dvs;

        dvs = _gm_.dvsize;
        _gm_.dvsize = 0;
        _gm_.dv = 0B;
        D.5863 = dvs | 3;
        p->head = D.5863;
        D.5864 = p + dvs;
        D.5864 = p + dvs;
        D.5865 = D.5864->head;
        D.5866 = D.5865 | 1;
        D.5864->head = D.5866;
      }
      <D.5862>:
      mem = p + 16;
      goto postaction;
    }
    <D.5856>:
    D.5867 = _gm_.topsize;
    if (D.5867 > nb) goto <D.5868>; else goto <D.5869>;
    <D.5868>:
    {
      size_t rsize;
      struct malloc_chunk * p;
      struct malloc_chunk * r;

      D.5867 = _gm_.topsize;
      D.5870 = D.5867 - nb;
      _gm_.topsize = D.5870;
      rsize = _gm_.topsize;
      p = _gm_.top;
      D.5871 = p + nb;
      _gm_.top = D.5871;
      r = _gm_.top;
      D.5872 = rsize | 1;
      r->head = D.5872;
      D.5824 = nb | 3;
      p->head = D.5824;
      mem = p + 16;
      goto postaction;
    }
    <D.5869>:
    mem = sys_alloc (&_gm_, nb);
    postaction:
    D.5743 = _gm_.mflags;
    D.5744 = D.5743 & 2;
    if (D.5744 != 0) goto <D.5873>; else goto <D.5874>;
    <D.5873>:
    pthread_mutex_unlock (&_gm_.mutex);
    <D.5874>:
    D.5875 = mem;
    return D.5875;
  }
  <D.5739>:
  D.5875 = 0B;
  return D.5875;
}


init_mparams ()
{
  long unsigned int D.5877;
  long unsigned int D.5880;
  unsigned int D.5883;
  long unsigned int D.5886;
  long unsigned int D.5887;
  long unsigned int D.5888;
  long unsigned int D.5890;
  long unsigned int D.5891;
  int D.5892;

  D.5877 = mparams.page_size;
  if (D.5877 == 0) goto <D.5878>; else goto <D.5879>;
  <D.5878>:
  {
    size_t s;

    mparams.mmap_threshold = 262144;
    mparams.trim_threshold = 2097152;
    mparams.default_mflags = 7;
    s = 1482184792;
    pthread_mutex_lock (&magic_init_mutex);
    D.5880 = mparams.magic;
    if (D.5880 == 0) goto <D.5881>; else goto <D.5882>;
    <D.5881>:
    mparams.magic = s;
    pthread_mutex_init (&_gm_.mutex, 0B);
    D.5883 = mparams.default_mflags;
    _gm_.mflags = D.5883;
    <D.5882>:
    pthread_mutex_unlock (&magic_init_mutex);
    mparams.page_size = 4096;
    mparams.granularity = 65536;
    D.5886 = mparams.granularity;
    D.5886 = mparams.granularity;
    D.5887 = D.5886 + 18446744073709551615;
    D.5888 = D.5886 & D.5887;
    if (D.5888 != 0) goto <D.5884>; else goto <D.5889>;
    <D.5889>:
    D.5877 = mparams.page_size;
    D.5877 = mparams.page_size;
    D.5890 = D.5877 + 18446744073709551615;
    D.5891 = D.5877 & D.5890;
    if (D.5891 != 0) goto <D.5884>; else goto <D.5885>;
    <D.5884>:
    abort ();
    <D.5885>:
  }
  <D.5879>:
  D.5892 = 0;
  return D.5892;
}


tmalloc_small (struct malloc_state * m, size_t nb)
{
  unsigned int D.5894;
  unsigned int D.5895;
  unsigned int D.5896;
  unsigned int D.5897;
  unsigned int K.5;
  unsigned int D.5899;
  unsigned int K.6;
  unsigned int D.5901;
  unsigned int K.7;
  unsigned int K.8;
  long unsigned int D.5904;
  long unsigned int D.5905;
  struct malloc_tree_chunk * iftmp.9;
  struct malloc_tree_chunk * D.5909;
  char * D.5913;
  _Bool D.5914;
  long int D.5915;
  long int D.5916;
  _Bool D.5919;
  long int D.5920;
  long int D.5921;
  struct malloc_tree_chunk * D.5924;
  _Bool D.5927;
  long int D.5928;
  long int D.5929;
  struct malloc_tree_chunk * D.5937;
  _Bool D.5939;
  long int D.5940;
  long int D.5941;
  unsigned int D.5947;
  struct malloc_tree_chunk * D.5948;
  unsigned int D.5953;
  unsigned int D.5954;
  unsigned int D.5955;
  _Bool D.5957;
  long int D.5958;
  long int D.5959;
  struct malloc_tree_chunk * D.5962;
  _Bool D.5969;
  long int D.5970;
  long int D.5971;
  _Bool D.5976;
  long int D.5977;
  long int D.5978;
  _Bool D.5984;
  long int D.5985;
  long int D.5986;
  long unsigned int D.5993;
  long unsigned int D.5994;
  struct malloc_chunk * D.5995;
  long unsigned int D.5996;
  long unsigned int D.5997;
  long unsigned int D.5999;
  long unsigned int D.6000;
  struct malloc_chunk * D.6001;
  long unsigned int D.6004;
  unsigned int D.6005;
  unsigned int D.6006;
  unsigned int D.6007;
  unsigned int D.6008;
  unsigned int D.6011;
  struct malloc_chunk * D.6013;
  _Bool D.6014;
  long int D.6015;
  long int D.6016;
  void * D.6020;
  struct malloc_tree_chunk * t;
  struct malloc_tree_chunk * v;
  size_t rsize;
  bindex_t i;
  binmap_t leastbit;

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

    Y = leastbit + 4294967295;
    D.5896 = Y >> 12;
    K = D.5896 & 16;
    N = K;
    Y = Y >> K;
    D.5897 = Y >> 5;
    K = D.5897 & 8;
    K.5 = K;
    N = K.5 + N;
    Y = Y >> K;
    D.5899 = Y >> 2;
    K = D.5899 & 4;
    K.6 = K;
    N = K.6 + N;
    Y = Y >> K;
    D.5901 = Y >> 1;
    K = D.5901 & 2;
    K.7 = K;
    N = K.7 + N;
    Y = Y >> K;
    D.5901 = Y >> 1;
    K = D.5901 & 1;
    K.8 = K;
    N = K.8 + N;
    Y = Y >> K;
    i = N + Y;
  }
  t = m->treebins[i];
  v = t;
  D.5904 = t->head;
  D.5905 = D.5904 & 18446744073709551612;
  rsize = D.5905 - nb;
  goto <D.5596>;
  <D.5595>:
  {
    size_t trem;

    D.5904 = t->head;
    D.5905 = D.5904 & 18446744073709551612;
    trem = D.5905 - nb;
    if (trem < rsize) goto <D.5906>; else goto <D.5907>;
    <D.5906>:
    rsize = trem;
    v = t;
    <D.5907>:
  }
  <D.5596>:
  D.5909 = t->child[0];
  if (D.5909 != 0B) goto <D.5910>; else goto <D.5911>;
  <D.5910>:
  iftmp.9 = t->child[0];
  goto <D.5912>;
  <D.5911>:
  iftmp.9 = t->child[1];
  <D.5912>:
  t = iftmp.9;
  if (t != 0B) goto <D.5595>; else goto <D.5597>;
  <D.5597>:
  D.5913 = m->least_addr;
  D.5914 = D.5913 <= v;
  D.5915 = (long int) D.5914;
  D.5916 = __builtin_expect (D.5915, 1);
  if (D.5916 != 0) goto <D.5917>; else goto <D.5918>;
  <D.5917>:
  {
    struct malloc_chunk * r;

    r = v + nb;
    D.5919 = v < r;
    D.5920 = (long int) D.5919;
    D.5921 = __builtin_expect (D.5920, 1);
    if (D.5921 != 0) goto <D.5922>; else goto <D.5923>;
    <D.5922>:
    {
      struct malloc_tree_chunk * XP;
      struct malloc_tree_chunk * R;

      XP = v->parent;
      D.5924 = v->bk;
      if (D.5924 != v) goto <D.5925>; else goto <D.5926>;
      <D.5925>:
      {
        struct malloc_tree_chunk * F;

        F = v->fd;
        R = v->bk;
        D.5913 = m->least_addr;
        D.5927 = D.5913 <= F;
        D.5928 = (long int) D.5927;
        D.5929 = __builtin_expect (D.5928, 1);
        if (D.5929 != 0) goto <D.5930>; else goto <D.5931>;
        <D.5930>:
        F->bk = R;
        R->fd = F;
        goto <D.5932>;
        <D.5931>:
        abort ();
        <D.5932>:
      }
      goto <D.5933>;
      <D.5926>:
      {
        struct malloc_tree_chunk * * RP;

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

          goto <D.5605>;
          <D.5604>:
          RP = CP;
          R = *RP;
          <D.5605>:
          CP = &R->child[1];
          D.5937 = *CP;
          if (D.5937 != 0B) goto <D.5604>; else goto <D.5938>;
          <D.5938>:
          CP = &R->child[0];
          D.5937 = *CP;
          if (D.5937 != 0B) goto <D.5604>; else goto <D.5606>;
          <D.5606>:
          D.5913 = m->least_addr;
          D.5939 = D.5913 <= RP;
          D.5940 = (long int) D.5939;
          D.5941 = __builtin_expect (D.5940, 1);
          if (D.5941 != 0) goto <D.5942>; else goto <D.5943>;
          <D.5942>:
          *RP = 0B;
          goto <D.5944>;
          <D.5943>:
          abort ();
          <D.5944>:
        }
        <D.5935>:
      }
      <D.5933>:
      if (XP != 0B) goto <D.5945>; else goto <D.5946>;
      <D.5945>:
      {
        struct malloc_tree_chunk * * H;

        D.5947 = v->index;
        H = &m->treebins[D.5947];
        D.5948 = *H;
        if (D.5948 == v) goto <D.5949>; else goto <D.5950>;
        <D.5949>:
        *H = R;
        D.5948 = *H;
        if (D.5948 == 0B) goto <D.5951>; else goto <D.5952>;
        <D.5951>:
        D.5894 = m->treemap;
        D.5947 = v->index;
        D.5953 = 1 << D.5947;
        D.5954 = ~D.5953;
        D.5955 = D.5894 & D.5954;
        m->treemap = D.5955;
        <D.5952>:
        goto <D.5956>;
        <D.5950>:
        D.5913 = m->least_addr;
        D.5957 = D.5913 <= XP;
        D.5958 = (long int) D.5957;
        D.5959 = __builtin_expect (D.5958, 1);
        if (D.5959 != 0) goto <D.5960>; else goto <D.5961>;
        <D.5960>:
        D.5962 = XP->child[0];
        if (D.5962 == v) goto <D.5963>; else goto <D.5964>;
        <D.5963>:
        XP->child[0] = R;
        goto <D.5965>;
        <D.5964>:
        XP->child[1] = R;
        <D.5965>:
        goto <D.5966>;
        <D.5961>:
        abort ();
        <D.5966>:
        <D.5956>:
        if (R != 0B) goto <D.5967>; else goto <D.5968>;
        <D.5967>:
        D.5913 = m->least_addr;
        D.5969 = D.5913 <= R;
        D.5970 = (long int) D.5969;
        D.5971 = __builtin_expect (D.5970, 1);
        if (D.5971 != 0) goto <D.5972>; else goto <D.5973>;
        <D.5972>:
        {
          struct malloc_tree_chunk * C0;
          struct malloc_tree_chunk * C1;

          R->parent = XP;
          C0 = v->child[0];
          if (C0 != 0B) goto <D.5974>; else goto <D.5975>;
          <D.5974>:
          D.5913 = m->least_addr;
          D.5976 = D.5913 <= C0;
          D.5977 = (long int) D.5976;
          D.5978 = __builtin_expect (D.5977, 1);
          if (D.5978 != 0) goto <D.5979>; else goto <D.5980>;
          <D.5979>:
          R->child[0] = C0;
          C0->parent = R;
          goto <D.5981>;
          <D.5980>:
          abort ();
          <D.5981>:
          <D.5975>:
          C1 = v->child[1];
          if (C1 != 0B) goto <D.5982>; else goto <D.5983>;
          <D.5982>:
          D.5913 = m->least_addr;
          D.5984 = D.5913 <= C1;
          D.5985 = (long int) D.5984;
          D.5986 = __builtin_expect (D.5985, 1);
          if (D.5986 != 0) goto <D.5987>; else goto <D.5988>;
          <D.5987>:
          R->child[1] = C1;
          C1->parent = R;
          goto <D.5989>;
          <D.5988>:
          abort ();
          <D.5989>:
          <D.5983>:
        }
        goto <D.5990>;
        <D.5973>:
        abort ();
        <D.5990>:
        <D.5968>:
      }
      <D.5946>:
    }
    if (rsize <= 31) goto <D.5991>; else goto <D.5992>;
    <D.5991>:
    D.5993 = rsize + nb;
    D.5994 = D.5993 | 3;
    v->head = D.5994;
    D.5993 = rsize + nb;
    D.5995 = v + D.5993;
    D.5993 = rsize + nb;
    D.5995 = v + D.5993;
    D.5996 = D.5995->head;
    D.5997 = D.5996 | 1;
    D.5995->head = D.5997;
    goto <D.5998>;
    <D.5992>:
    D.5999 = nb | 3;
    v->head = D.5999;
    D.6000 = rsize | 1;
    r->head = D.6000;
    D.6001 = r + rsize;
    D.6001->prev_foot = rsize;
    {
      size_t DVS;

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

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

          D.6004 = DVS >> 3;
          I = (bindex_t) D.6004;
          D.6005 = I << 1;
          B = &m->smallbins[D.6005];
          F = B;
          D.6006 = m->smallmap;
          D.6007 = 1 << I;
          D.6008 = D.6006 & D.6007;
          if (D.6008 == 0) goto <D.6009>; else goto <D.6010>;
          <D.6009>:
          D.6006 = m->smallmap;
          D.6007 = 1 << I;
          D.6011 = D.6006 | D.6007;
          m->smallmap = D.6011;
          goto <D.6012>;
          <D.6010>:
          D.6013 = B->fd;
          D.5913 = m->least_addr;
          D.6014 = D.6013 >= D.5913;
          D.6015 = (long int) D.6014;
          D.6016 = __builtin_expect (D.6015, 1);
          if (D.6016 != 0) goto <D.6017>; else goto <D.6018>;
          <D.6017>:
          F = B->fd;
          goto <D.6019>;
          <D.6018>:
          abort ();
          <D.6019>:
          <D.6012>:
          B->fd = DV;
          F->bk = DV;
          DV->fd = F;
          DV->bk = B;
        }
      }
      <D.6003>:
      m->dvsize = rsize;
      m->dv = r;
    }
    <D.5998>:
    D.6020 = v + 16;
    return D.6020;
    <D.5923>:
  }
  <D.5918>:
  abort ();
  D.6020 = 0B;
  return D.6020;
}


tmalloc_large (struct malloc_state * m, size_t nb)
{
  unsigned int D.6028;
  unsigned int D.6029;
  unsigned int D.6030;
  unsigned int D.6031;
  unsigned int D.6032;
  unsigned int D.6033;
  unsigned int K.10;
  unsigned int D.6035;
  unsigned int D.6036;
  unsigned int D.6037;
  unsigned int D.6038;
  long unsigned int D.6039;
  unsigned int D.6040;
  unsigned int D.6041;
  unsigned int iftmp.11;
  unsigned int D.6047;
  long unsigned int D.6049;
  long unsigned int D.6050;
  long unsigned int D.6054;
  unsigned int D.6065;
  unsigned int D.6066;
  unsigned int D.6067;
  unsigned int D.6068;
  unsigned int D.6069;
  unsigned int D.6072;
  unsigned int D.6073;
  unsigned int D.6074;
  unsigned int K.12;
  unsigned int D.6076;
  unsigned int K.13;
  unsigned int D.6078;
  unsigned int K.14;
  unsigned int K.15;
  struct malloc_tree_chunk * iftmp.16;
  struct malloc_tree_chunk * D.6084;
  long unsigned int D.6090;
  long unsigned int D.6091;
  char * D.6094;
  _Bool D.6095;
  long int D.6096;
  long int D.6097;
  _Bool D.6100;
  long int D.6101;
  long int D.6102;
  struct malloc_tree_chunk * D.6105;
  _Bool D.6108;
  long int D.6109;
  long int D.6110;
  struct malloc_tree_chunk * D.6118;
  _Bool D.6120;
  long int D.6121;
  long int D.6122;
  unsigned int D.6128;
  struct malloc_tree_chunk * D.6129;
  unsigned int D.6134;
  unsigned int D.6135;
  unsigned int D.6136;
  _Bool D.6138;
  long int D.6139;
  long int D.6140;
  struct malloc_tree_chunk * D.6143;
  _Bool D.6150;
  long int D.6151;
  long int D.6152;
  _Bool D.6157;
  long int D.6158;
  long int D.6159;
  _Bool D.6165;
  long int D.6166;
  long int D.6167;
  long unsigned int D.6174;
  long unsigned int D.6175;
  struct malloc_chunk * D.6176;
  long unsigned int D.6177;
  long unsigned int D.6178;
  long unsigned int D.6180;
  long unsigned int D.6181;
  struct malloc_chunk * D.6182;
  long unsigned int D.6183;
  unsigned int D.6186;
  unsigned int D.6187;
  unsigned int D.6188;
  unsigned int D.6189;
  unsigned int D.6192;
  struct malloc_chunk * D.6194;
  _Bool D.6195;
  long int D.6196;
  long int D.6197;
  unsigned int D.6208;
  unsigned int D.6209;
  unsigned int D.6210;
  unsigned int D.6211;
  unsigned int D.6212;
  unsigned int D.6213;
  unsigned int K.17;
  unsigned int D.6215;
  unsigned int D.6216;
  unsigned int D.6217;
  unsigned int D.6218;
  long unsigned int D.6219;
  unsigned int D.6220;
  unsigned int D.6221;
  struct malloc_tree_chunk * D.6222;
  unsigned int D.6223;
  unsigned int D.6224;
  unsigned int D.6227;
  struct malloc_tree_chunk * D.6228;
  unsigned int iftmp.18;
  unsigned int D.6233;
  long unsigned int D.6235;
  long unsigned int D.6236;
  long unsigned int D.6239;
  struct malloc_tree_chunk * D.6240;
  _Bool D.6244;
  long int D.6245;
  long int D.6246;
  _Bool D.6251;
  long int D.6252;
  long int D.6253;
  _Bool D.6255;
  long int D.6256;
  long int D.6257;
  struct malloc_tree_chunk * D.6259;
  void * D.6260;
  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.6022>; else goto <D.6023>;
    <D.6022>:
    idx = 0;
    goto <D.6024>;
    <D.6023>:
    if (X > 65535) goto <D.6025>; else goto <D.6026>;
    <D.6025>:
    idx = 31;
    goto <D.6027>;
    <D.6026>:
    {
      unsigned int Y;
      unsigned int N;
      unsigned int K;

      Y = (unsigned int) X;
      D.6028 = Y + 4294967040;
      D.6029 = D.6028 >> 16;
      N = D.6029 & 8;
      Y = Y << N;
      D.6030 = Y + 4294963200;
      D.6031 = D.6030 >> 16;
      K = D.6031 & 4;
      N = N + K;
      Y = Y << K;
      D.6032 = Y + 4294950912;
      D.6033 = D.6032 >> 16;
      K = D.6033 & 2;
      K.10 = K;
      N = K.10 + N;
      Y = Y << K;
      D.6035 = Y >> 15;
      D.6036 = D.6035 - N;
      K = D.6036 + 14;
      D.6037 = K << 1;
      D.6038 = K + 7;
      D.6039 = nb >> D.6038;
      D.6040 = (unsigned int) D.6039;
      D.6041 = D.6040 & 1;
      idx = D.6037 + D.6041;
    }
    <D.6027>:
    <D.6024>:
  }
  t = m->treebins[idx];
  if (t != 0B) goto <D.6042>; else goto <D.6043>;
  <D.6042>:
  {
    size_t sizebits;
    struct malloc_tree_chunk * rst;

    if (idx != 31) goto <D.6045>; else goto <D.6046>;
    <D.6045>:
    D.6047 = idx >> 1;
    iftmp.11 = 57 - D.6047;
    goto <D.6048>;
    <D.6046>:
    iftmp.11 = 0;
    <D.6048>:
    sizebits = nb << iftmp.11;
    rst = 0B;
    <D.5543>:
    {
      struct malloc_tree_chunk * rt;
      size_t trem;

      D.6049 = t->head;
      D.6050 = D.6049 & 18446744073709551612;
      trem = D.6050 - nb;
      if (trem < rsize) goto <D.6051>; else goto <D.6052>;
      <D.6051>:
      v = t;
      rsize = trem;
      if (rsize == 0) goto <D.5542>; else goto <D.6053>;
      <D.6053>:
      <D.6052>:
      rt = t->child[1];
      D.6054 = sizebits >> 63;
      t = t->child[D.6054];
      if (rt != 0B) goto <D.6055>; else goto <D.6056>;
      <D.6055>:
      if (rt != t) goto <D.6057>; else goto <D.6058>;
      <D.6057>:
      rst = rt;
      <D.6058>:
      <D.6056>:
      if (t == 0B) goto <D.6059>; else goto <D.6060>;
      <D.6059>:
      t = rst;
      goto <D.5542>;
      <D.6060>:
      sizebits = sizebits << 1;
    }
    goto <D.5543>;
    <D.5542>:
  }
  <D.6043>:
  if (t == 0B) goto <D.6061>; else goto <D.6062>;
  <D.6061>:
  if (v == 0B) goto <D.6063>; else goto <D.6064>;
  <D.6063>:
  {
    binmap_t leftbits;

    D.6065 = 1 << idx;
    D.6066 = D.6065 << 1;
    D.6065 = 1 << idx;
    D.6066 = D.6065 << 1;
    D.6067 = -D.6066;
    D.6068 = D.6066 | D.6067;
    D.6069 = m->treemap;
    leftbits = D.6068 & D.6069;
    if (leftbits != 0) goto <D.6070>; else goto <D.6071>;
    <D.6070>:
    {
      bindex_t i;
      binmap_t leastbit;

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

        Y = leastbit + 4294967295;
        D.6073 = Y >> 12;
        K = D.6073 & 16;
        N = K;
        Y = Y >> K;
        D.6074 = Y >> 5;
        K = D.6074 & 8;
        K.12 = K;
        N = K.12 + N;
        Y = Y >> K;
        D.6076 = Y >> 2;
        K = D.6076 & 4;
        K.13 = K;
        N = K.13 + N;
        Y = Y >> K;
        D.6078 = Y >> 1;
        K = D.6078 & 2;
        K.14 = K;
        N = K.14 + N;
        Y = Y >> K;
        D.6078 = Y >> 1;
        K = D.6078 & 1;
        K.15 = K;
        N = K.15 + N;
        Y = Y >> K;
        i = N + Y;
      }
      t = m->treebins[i];
    }
    <D.6071>:
  }
  <D.6064>:
  <D.6062>:
  goto <D.5552>;
  <D.5551>:
  {
    size_t trem;

    D.6049 = t->head;
    D.6050 = D.6049 & 18446744073709551612;
    trem = D.6050 - nb;
    if (trem < rsize) goto <D.6081>; else goto <D.6082>;
    <D.6081>:
    rsize = trem;
    v = t;
    <D.6082>:
    D.6084 = t->child[0];
    if (D.6084 != 0B) goto <D.6085>; else goto <D.6086>;
    <D.6085>:
    iftmp.16 = t->child[0];
    goto <D.6087>;
    <D.6086>:
    iftmp.16 = t->child[1];
    <D.6087>:
    t = iftmp.16;
  }
  <D.5552>:
  if (t != 0B) goto <D.5551>; else goto <D.5553>;
  <D.5553>:
  if (v != 0B) goto <D.6088>; else goto <D.6089>;
  <D.6088>:
  D.6090 = m->dvsize;
  D.6091 = D.6090 - nb;
  if (D.6091 > rsize) goto <D.6092>; else goto <D.6093>;
  <D.6092>:
  D.6094 = m->least_addr;
  D.6095 = D.6094 <= v;
  D.6096 = (long int) D.6095;
  D.6097 = __builtin_expect (D.6096, 1);
  if (D.6097 != 0) goto <D.6098>; else goto <D.6099>;
  <D.6098>:
  {
    struct malloc_chunk * r;

    r = v + nb;
    D.6100 = v < r;
    D.6101 = (long int) D.6100;
    D.6102 = __builtin_expect (D.6101, 1);
    if (D.6102 != 0) goto <D.6103>; else goto <D.6104>;
    <D.6103>:
    {
      struct malloc_tree_chunk * XP;
      struct malloc_tree_chunk * R;

      XP = v->parent;
      D.6105 = v->bk;
      if (D.6105 != v) goto <D.6106>; else goto <D.6107>;
      <D.6106>:
      {
        struct malloc_tree_chunk * F;

        F = v->fd;
        R = v->bk;
        D.6094 = m->least_addr;
        D.6108 = D.6094 <= F;
        D.6109 = (long int) D.6108;
        D.6110 = __builtin_expect (D.6109, 1);
        if (D.6110 != 0) goto <D.6111>; else goto <D.6112>;
        <D.6111>:
        F->bk = R;
        R->fd = F;
        goto <D.6113>;
        <D.6112>:
        abort ();
        <D.6113>:
      }
      goto <D.6114>;
      <D.6107>:
      {
        struct malloc_tree_chunk * * RP;

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

          goto <D.5561>;
          <D.5560>:
          RP = CP;
          R = *RP;
          <D.5561>:
          CP = &R->child[1];
          D.6118 = *CP;
          if (D.6118 != 0B) goto <D.5560>; else goto <D.6119>;
          <D.6119>:
          CP = &R->child[0];
          D.6118 = *CP;
          if (D.6118 != 0B) goto <D.5560>; else goto <D.5562>;
          <D.5562>:
          D.6094 = m->least_addr;
          D.6120 = D.6094 <= RP;
          D.6121 = (long int) D.6120;
          D.6122 = __builtin_expect (D.6121, 1);
          if (D.6122 != 0) goto <D.6123>; else goto <D.6124>;
          <D.6123>:
          *RP = 0B;
          goto <D.6125>;
          <D.6124>:
          abort ();
          <D.6125>:
        }
        <D.6116>:
      }
      <D.6114>:
      if (XP != 0B) goto <D.6126>; else goto <D.6127>;
      <D.6126>:
      {
        struct malloc_tree_chunk * * H;

        D.6128 = v->index;
        H = &m->treebins[D.6128];
        D.6129 = *H;
        if (D.6129 == v) goto <D.6130>; else goto <D.6131>;
        <D.6130>:
        *H = R;
        D.6129 = *H;
        if (D.6129 == 0B) goto <D.6132>; else goto <D.6133>;
        <D.6132>:
        D.6069 = m->treemap;
        D.6128 = v->index;
        D.6134 = 1 << D.6128;
        D.6135 = ~D.6134;
        D.6136 = D.6069 & D.6135;
        m->treemap = D.6136;
        <D.6133>:
        goto <D.6137>;
        <D.6131>:
        D.6094 = m->least_addr;
        D.6138 = D.6094 <= XP;
        D.6139 = (long int) D.6138;
        D.6140 = __builtin_expect (D.6139, 1);
        if (D.6140 != 0) goto <D.6141>; else goto <D.6142>;
        <D.6141>:
        D.6143 = XP->child[0];
        if (D.6143 == v) goto <D.6144>; else goto <D.6145>;
        <D.6144>:
        XP->child[0] = R;
        goto <D.6146>;
        <D.6145>:
        XP->child[1] = R;
        <D.6146>:
        goto <D.6147>;
        <D.6142>:
        abort ();
        <D.6147>:
        <D.6137>:
        if (R != 0B) goto <D.6148>; else goto <D.6149>;
        <D.6148>:
        D.6094 = m->least_addr;
        D.6150 = D.6094 <= R;
        D.6151 = (long int) D.6150;
        D.6152 = __builtin_expect (D.6151, 1);
        if (D.6152 != 0) goto <D.6153>; else goto <D.6154>;
        <D.6153>:
        {
          struct malloc_tree_chunk * C0;
          struct malloc_tree_chunk * C1;

          R->parent = XP;
          C0 = v->child[0];
          if (C0 != 0B) goto <D.6155>; else goto <D.6156>;
          <D.6155>:
          D.6094 = m->least_addr;
          D.6157 = D.6094 <= C0;
          D.6158 = (long int) D.6157;
          D.6159 = __builtin_expect (D.6158, 1);
          if (D.6159 != 0) goto <D.6160>; else goto <D.6161>;
          <D.6160>:
          R->child[0] = C0;
          C0->parent = R;
          goto <D.6162>;
          <D.6161>:
          abort ();
          <D.6162>:
          <D.6156>:
          C1 = v->child[1];
          if (C1 != 0B) goto <D.6163>; else goto <D.6164>;
          <D.6163>:
          D.6094 = m->least_addr;
          D.6165 = D.6094 <= C1;
          D.6166 = (long int) D.6165;
          D.6167 = __builtin_expect (D.6166, 1);
          if (D.6167 != 0) goto <D.6168>; else goto <D.6169>;
          <D.6168>:
          R->child[1] = C1;
          C1->parent = R;
          goto <D.6170>;
          <D.6169>:
          abort ();
          <D.6170>:
          <D.6164>:
        }
        goto <D.6171>;
        <D.6154>:
        abort ();
        <D.6171>:
        <D.6149>:
      }
      <D.6127>:
    }
    if (rsize <= 31) goto <D.6172>; else goto <D.6173>;
    <D.6172>:
    D.6174 = rsize + nb;
    D.6175 = D.6174 | 3;
    v->head = D.6175;
    D.6174 = rsize + nb;
    D.6176 = v + D.6174;
    D.6174 = rsize + nb;
    D.6176 = v + D.6174;
    D.6177 = D.6176->head;
    D.6178 = D.6177 | 1;
    D.6176->head = D.6178;
    goto <D.6179>;
    <D.6173>:
    D.6180 = nb | 3;
    v->head = D.6180;
    D.6181 = rsize | 1;
    r->head = D.6181;
    D.6182 = r + rsize;
    D.6182->prev_foot = rsize;
    D.6183 = rsize >> 3;
    if (D.6183 <= 31) goto <D.6184>; else goto <D.6185>;
    <D.6184>:
    {
      bindex_t I;
      struct malloc_chunk * B;
      struct malloc_chunk * F;

      D.6183 = rsize >> 3;
      I = (bindex_t) D.6183;
      D.6186 = I << 1;
      B = &m->smallbins[D.6186];
      F = B;
      D.6187 = m->smallmap;
      D.6188 = 1 << I;
      D.6189 = D.6187 & D.6188;
      if (D.6189 == 0) goto <D.6190>; else goto <D.6191>;
      <D.6190>:
      D.6187 = m->smallmap;
      D.6188 = 1 << I;
      D.6192 = D.6187 | D.6188;
      m->smallmap = D.6192;
      goto <D.6193>;
      <D.6191>:
      D.6194 = B->fd;
      D.6094 = m->least_addr;
      D.6195 = D.6194 >= D.6094;
      D.6196 = (long int) D.6195;
      D.6197 = __builtin_expect (D.6196, 1);
      if (D.6197 != 0) goto <D.6198>; else goto <D.6199>;
      <D.6198>:
      F = B->fd;
      goto <D.6200>;
      <D.6199>:
      abort ();
      <D.6200>:
      <D.6193>:
      B->fd = r;
      F->bk = r;
      r->fd = F;
      r->bk = B;
    }
    goto <D.6201>;
    <D.6185>:
    {
      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.6202>; else goto <D.6203>;
          <D.6202>:
          I = 0;
          goto <D.6204>;
          <D.6203>:
          if (X > 65535) goto <D.6205>; else goto <D.6206>;
          <D.6205>:
          I = 31;
          goto <D.6207>;
          <D.6206>:
          {
            unsigned int Y;
            unsigned int N;
            unsigned int K;

            Y = (unsigned int) X;
            D.6208 = Y + 4294967040;
            D.6209 = D.6208 >> 16;
            N = D.6209 & 8;
            Y = Y << N;
            D.6210 = Y + 4294963200;
            D.6211 = D.6210 >> 16;
            K = D.6211 & 4;
            N = N + K;
            Y = Y << K;
            D.6212 = Y + 4294950912;
            D.6213 = D.6212 >> 16;
            K = D.6213 & 2;
            K.17 = K;
            N = K.17 + N;
            Y = Y << K;
            D.6215 = Y >> 15;
            D.6216 = D.6215 - N;
            K = D.6216 + 14;
            D.6217 = K << 1;
            D.6218 = K + 7;
            D.6219 = rsize >> D.6218;
            D.6220 = (unsigned int) D.6219;
            D.6221 = D.6220 & 1;
            I = D.6217 + D.6221;
          }
          <D.6207>:
          <D.6204>:
        }
        H = &m->treebins[I];
        TP->index = I;
        TP->child[1] = 0B;
        D.6222 = TP->child[1];
        TP->child[0] = D.6222;
        D.6069 = m->treemap;
        D.6223 = 1 << I;
        D.6224 = D.6069 & D.6223;
        if (D.6224 == 0) goto <D.6225>; else goto <D.6226>;
        <D.6225>:
        D.6069 = m->treemap;
        D.6223 = 1 << I;
        D.6227 = D.6069 | D.6223;
        m->treemap = D.6227;
        *H = TP;
        TP->parent = H;
        TP->bk = TP;
        D.6228 = TP->bk;
        TP->fd = D.6228;
        goto <D.6229>;
        <D.6226>:
        {
          struct malloc_tree_chunk * T;
          size_t K;

          T = *H;
          if (I != 31) goto <D.6231>; else goto <D.6232>;
          <D.6231>:
          D.6233 = I >> 1;
          iftmp.18 = 57 - D.6233;
          goto <D.6234>;
          <D.6232>:
          iftmp.18 = 0;
          <D.6234>:
          K = rsize << iftmp.18;
          <D.5581>:
          D.6235 = T->head;
          D.6236 = D.6235 & 18446744073709551612;
          if (D.6236 != rsize) goto <D.6237>; else goto <D.6238>;
          <D.6237>:
          {
            struct malloc_tree_chunk * * C;

            D.6239 = K >> 63;
            C = &T->child[D.6239];
            K = K << 1;
            D.6240 = *C;
            if (D.6240 != 0B) goto <D.6241>; else goto <D.6242>;
            <D.6241>:
            T = *C;
            goto <D.6243>;
            <D.6242>:
            D.6094 = m->least_addr;
            D.6244 = D.6094 <= C;
            D.6245 = (long int) D.6244;
            D.6246 = __builtin_expect (D.6245, 1);
            if (D.6246 != 0) goto <D.6247>; else goto <D.6248>;
            <D.6247>:
            *C = TP;
            TP->parent = T;
            TP->bk = TP;
            D.6228 = TP->bk;
            TP->fd = D.6228;
            goto <D.5579>;
            <D.6248>:
            abort ();
            <D.6243>:
          }
          goto <D.6249>;
          <D.6238>:
          {
            struct malloc_tree_chunk * F;

            F = T->fd;
            D.6094 = m->least_addr;
            D.6251 = D.6094 <= T;
            D.6252 = (long int) D.6251;
            D.6253 = __builtin_expect (D.6252, 1);
            if (D.6253 != 0) goto <D.6254>; else goto <D.6250>;
            <D.6254>:
            D.6094 = m->least_addr;
            D.6255 = D.6094 <= F;
            D.6256 = (long int) D.6255;
            D.6257 = __builtin_expect (D.6256, 1);
            if (D.6257 != 0) goto <D.6258>; else goto <D.6250>;
            <D.6258>:
            F->bk = TP;
            D.6259 = F->bk;
            T->fd = D.6259;
            TP->fd = F;
            TP->bk = T;
            TP->parent = 0B;
            goto <D.5579>;
            <D.6250>:
            abort ();
          }
          <D.6249>:
          goto <D.5581>;
          <D.5579>:
        }
        <D.6229>:
      }
    }
    <D.6201>:
    <D.6179>:
    D.6260 = v + 16;
    return D.6260;
    <D.6104>:
  }
  <D.6099>:
  abort ();
  <D.6093>:
  <D.6089>:
  D.6260 = 0B;
  return D.6260;
}


sys_alloc (struct malloc_state * m, size_t nb)
{
  unsigned int D.6262;
  long unsigned int D.6263;
  long unsigned int D.6264;
  long unsigned int D.6267;
  void * D.6272;
  struct malloc_segment * iftmp.19;
  struct malloc_chunk * D.6276;
  long unsigned int D.6284;
  long unsigned int D.6285;
  long unsigned int D.6286;
  long unsigned int D.6287;
  long unsigned int D.6288;
  long unsigned int D.6289;
  long unsigned int base.20;
  long unsigned int D.6291;
  long unsigned int D.6294;
  long unsigned int D.6295;
  long unsigned int D.6296;
  long unsigned int D.6297;
  long unsigned int D.6303;
  long unsigned int D.6304;
  long unsigned int D.6305;
  long unsigned int D.6306;
  char * D.6309;
  long unsigned int D.6310;
  char * D.6311;
  long unsigned int D.6320;
  long unsigned int D.6323;
  long unsigned int D.6324;
  long unsigned int D.6325;
  unsigned int D.6334;
  long unsigned int D.6337;
  long int end.21;
  long int br.22;
  long int D.6354;
  long unsigned int D.6355;
  long unsigned int D.6360;
  long unsigned int D.6361;
  long unsigned int D.6362;
  char * D.6367;
  long unsigned int D.6368;
  long unsigned int D.6371;
  struct malloc_chunk * D.6373;
  long unsigned int D.6374;
  sizetype D.6375;
  sizetype D.6376;
  char * D.6377;
  long int D.6378;
  long int mn.23;
  long int D.6380;
  long unsigned int D.6381;
  long unsigned int D.6382;
  char * D.6385;
  long unsigned int D.6386;
  char * D.6387;
  unsigned int D.6391;
  unsigned int D.6392;
  long unsigned int D.6394;
  long unsigned int D.6395;
  long unsigned int D.6396;
  long unsigned int D.6400;
  long unsigned int D.6401;
  long unsigned int D.6411;
  struct malloc_chunk * D.6412;
  long unsigned int D.6413;
  long unsigned int D.6414;
  int * D.6415;
  char * tbase;
  size_t tsize;
  flag_t mmap_flag;

  tbase = -1B;
  tsize = 0;
  mmap_flag = 0;
  init_mparams ();
  D.6262 = m->mflags;
  D.6263 = (long unsigned int) D.6262;
  D.6264 = D.6263 & 1;
  if (D.6264 != 0) goto <D.6265>; else goto <D.6266>;
  <D.6265>:
  D.6267 = mparams.mmap_threshold;
  if (D.6267 <= nb) goto <D.6268>; else goto <D.6269>;
  <D.6268>:
  {
    void * mem;

    mem = mmap_alloc (m, nb);
    if (mem != 0B) goto <D.6270>; else goto <D.6271>;
    <D.6270>:
    D.6272 = mem;
    return D.6272;
    <D.6271>:
  }
  <D.6269>:
  <D.6266>:
  if (0 != 0) goto <D.6273>; else goto <D.6274>;
  <D.6273>:
  {
    char * br;
    struct malloc_segment * ss;
    size_t asize;

    br = -1B;
    D.6276 = m->top;
    if (D.6276 != 0B) goto <D.6277>; else goto <D.6278>;
    <D.6277>:
    D.6276 = m->top;
    iftmp.19 = segment_holding (m, D.6276);
    goto <D.6279>;
    <D.6278>:
    iftmp.19 = 0B;
    <D.6279>:
    ss = iftmp.19;
    asize = 0;
    if (ss == 0B) goto <D.6280>; else goto <D.6281>;
    <D.6280>:
    {
      char * base;

      base = -1B;
      if (base != -1B) goto <D.6282>; else goto <D.6283>;
      <D.6282>:
      D.6284 = mparams.granularity;
      D.6285 = D.6284 + nb;
      D.6286 = D.6285 + 73;
      D.6284 = mparams.granularity;
      D.6287 = -D.6284;
      asize = D.6286 & D.6287;
      D.6288 = mparams.page_size;
      D.6289 = D.6288 + 18446744073709551615;
      base.20 = (long unsigned int) base;
      D.6291 = D.6289 & base.20;
      if (D.6291 != 0) goto <D.6292>; else goto <D.6293>;
      <D.6292>:
      D.6288 = mparams.page_size;
      base.20 = (long unsigned int) base;
      D.6294 = D.6288 + base.20;
      D.6288 = mparams.page_size;
      D.6295 = -D.6288;
      D.6296 = D.6294 & D.6295;
      base.20 = (long unsigned int) base;
      D.6297 = D.6296 - base.20;
      asize = D.6297 + asize;
      <D.6293>:
      if (asize <= 9223372036854775806) goto <D.6298>; else goto <D.6299>;
      <D.6298>:
      br = -1B;
      if (br == base) goto <D.6300>; else goto <D.6301>;
      <D.6300>:
      tbase = base;
      tsize = asize;
      <D.6301>:
      <D.6299>:
      <D.6283>:
    }
    goto <D.6302>;
    <D.6281>:
    D.6303 = m->topsize;
    D.6304 = nb - D.6303;
    D.6284 = mparams.granularity;
    D.6305 = D.6304 + D.6284;
    D.6306 = D.6305 + 73;
    D.6284 = mparams.granularity;
    D.6287 = -D.6284;
    asize = D.6306 & D.6287;
    if (asize <= 9223372036854775806) goto <D.6307>; else goto <D.6308>;
    <D.6307>:
    br = -1B;
    D.6309 = ss->base;
    D.6310 = ss->size;
    D.6311 = D.6309 + D.6310;
    if (br == D.6311) goto <D.6312>; else goto <D.6313>;
    <D.6312>:
    tbase = br;
    tsize = asize;
    <D.6313>:
    <D.6308>:
    <D.6302>:
    if (tbase == -1B) goto <D.6314>; else goto <D.6315>;
    <D.6314>:
    if (br != -1B) goto <D.6316>; else goto <D.6317>;
    <D.6316>:
    if (asize <= 9223372036854775806) goto <D.6318>; else goto <D.6319>;
    <D.6318>:
    D.6320 = nb + 73;
    if (D.6320 > asize) goto <D.6321>; else goto <D.6322>;
    <D.6321>:
    {
      size_t esize;

      D.6323 = nb - asize;
      D.6284 = mparams.granularity;
      D.6324 = D.6323 + D.6284;
      D.6325 = D.6324 + 73;
      D.6284 = mparams.granularity;
      D.6287 = -D.6284;
      esize = D.6325 & D.6287;
      if (esize <= 9223372036854775806) goto <D.6326>; else goto <D.6327>;
      <D.6326>:
      {
        char * end;

        end = -1B;
        if (end != -1B) goto <D.6328>; else goto <D.6329>;
        <D.6328>:
        asize = asize + esize;
        goto <D.6330>;
        <D.6329>:
        br = -1B;
        <D.6330>:
      }
      <D.6327>:
    }
    <D.6322>:
    <D.6319>:
    <D.6317>:
    if (br != -1B) goto <D.6331>; else goto <D.6332>;
    <D.6331>:
    tbase = br;
    tsize = asize;
    goto <D.6333>;
    <D.6332>:
    D.6262 = m->mflags;
    D.6334 = D.6262 | 4;
    m->mflags = D.6334;
    <D.6333>:
    <D.6315>:
  }
  <D.6274>:
  if (tbase == -1B) goto <D.6335>; else goto <D.6336>;
  <D.6335>:
  {
    size_t req;
    size_t rsize;

    req = nb + 73;
    D.6284 = mparams.granularity;
    D.6337 = D.6284 + req;
    D.6284 = mparams.granularity;
    D.6287 = -D.6284;
    rsize = D.6337 & D.6287;
    if (rsize > nb) goto <D.6338>; else goto <D.6339>;
    <D.6338>:
    {
      char * mp;

      mp = mmap (0B, rsize, 7, 34, -1, 0);
      if (mp != -1B) goto <D.6340>; else goto <D.6341>;
      <D.6340>:
      tbase = mp;
      tsize = rsize;
      mmap_flag = 1;
      <D.6341>:
    }
    <D.6339>:
  }
  <D.6336>:
  if (0 != 0) goto <D.6342>; else goto <D.6343>;
  <D.6342>:
  {
    size_t asize;

    D.6284 = mparams.granularity;
    D.6285 = D.6284 + nb;
    D.6286 = D.6285 + 73;
    D.6284 = mparams.granularity;
    D.6287 = -D.6284;
    asize = D.6286 & D.6287;
    if (asize <= 9223372036854775806) goto <D.6344>; else goto <D.6345>;
    <D.6344>:
    {
      char * br;
      char * end;

      br = -1B;
      end = -1B;
      br = -1B;
      end = -1B;
      if (br != -1B) goto <D.6346>; else goto <D.6347>;
      <D.6346>:
      if (end != -1B) goto <D.6348>; else goto <D.6349>;
      <D.6348>:
      if (br < end) goto <D.6350>; else goto <D.6351>;
      <D.6350>:
      {
        size_t ssize;

        end.21 = (long int) end;
        br.22 = (long int) br;
        D.6354 = end.21 - br.22;
        ssize = (size_t) D.6354;
        D.6355 = nb + 72;
        if (D.6355 < ssize) goto <D.6356>; else goto <D.6357>;
        <D.6356>:
        tbase = br;
        tsize = ssize;
        <D.6357>:
      }
      <D.6351>:
      <D.6349>:
      <D.6347>:
    }
    <D.6345>:
  }
  <D.6343>:
  if (tbase != -1B) goto <D.6358>; else goto <D.6359>;
  <D.6358>:
  D.6360 = m->footprint;
  D.6361 = D.6360 + tsize;
  m->footprint = D.6361;
  D.6360 = m->footprint;
  D.6362 = m->max_footprint;
  if (D.6360 > D.6362) goto <D.6363>; else goto <D.6364>;
  <D.6363>:
  D.6360 = m->footprint;
  m->max_footprint = D.6360;
  <D.6364>:
  D.6276 = m->top;
  if (D.6276 == 0B) goto <D.6365>; else goto <D.6366>;
  <D.6365>:
  m->least_addr = tbase;
  D.6367 = m->least_addr;
  m->seg.base = D.6367;
  m->seg.size = tsize;
  m->seg.sflags = mmap_flag;
  D.6368 = mparams.magic;
  m->magic = D.6368;
  init_bins (m);
  if (m == &_gm_) goto <D.6369>; else goto <D.6370>;
  <D.6369>:
  D.6371 = tsize + 18446744073709551544;
  init_top (m, tbase, D.6371);
  goto <D.6372>;
  <D.6370>:
  {
    struct malloc_chunk * mn;

    D.6373 = m + 18446744073709551600;
    D.6374 = D.6373->head;
    D.6375 = D.6374 & 18446744073709551612;
    D.6376 = D.6375 + 18446744073709551600;
    mn = m + D.6376;
    D.6377 = tbase + tsize;
    D.6378 = (long int) D.6377;
    mn.23 = (long int) mn;
    D.6380 = D.6378 - mn.23;
    D.6381 = (long unsigned int) D.6380;
    D.6382 = D.6381 + 18446744073709551544;
    init_top (m, mn, D.6382);
  }
  <D.6372>:
  goto <D.6383>;
  <D.6366>:
  {
    struct malloc_segment * sp;

    sp = &m->seg;
    goto <D.5467>;
    <D.5466>:
    sp = sp->next;
    <D.5467>:
    if (sp != 0B) goto <D.6384>; else goto <D.5468>;
    <D.6384>:
    D.6385 = sp->base;
    D.6386 = sp->size;
    D.6387 = D.6385 + D.6386;
    if (D.6387 != tbase) goto <D.5466>; else goto <D.5468>;
    <D.5468>:
    if (sp != 0B) goto <D.6390>; else goto <D.6388>;
    <D.6390>:
    D.6391 = sp->sflags;
    D.6392 = D.6391 & 8;
    if (D.6392 == 0) goto <D.6393>; else goto <D.6388>;
    <D.6393>:
    D.6391 = sp->sflags;
    D.6394 = (long unsigned int) D.6391;
    D.6395 = D.6394 & 1;
    D.6396 = (long unsigned int) mmap_flag;
    if (D.6395 == D.6396) goto <D.6397>; else goto <D.6388>;
    <D.6397>:
    D.6276 = m->top;
    D.6385 = sp->base;
    if (D.6276 >= D.6385) goto <D.6398>; else goto <D.6388>;
    <D.6398>:
    D.6276 = m->top;
    D.6385 = sp->base;
    D.6386 = sp->size;
    D.6387 = D.6385 + D.6386;
    if (D.6276 < D.6387) goto <D.6399>; else goto <D.6388>;
    <D.6399>:
    D.6386 = sp->size;
    D.6400 = D.6386 + tsize;
    sp->size = D.6400;
    D.6276 = m->top;
    D.6303 = m->topsize;
    D.6401 = D.6303 + tsize;
    init_top (m, D.6276, D.6401);
    goto <D.6389>;
    <D.6388>:
    D.6367 = m->least_addr;
    if (D.6367 > tbase) goto <D.6402>; else goto <D.6403>;
    <D.6402>:
    m->least_addr = tbase;
    <D.6403>:
    sp = &m->seg;
    goto <D.5470>;
    <D.5469>:
    sp = sp->next;
    <D.5470>:
    if (sp != 0B) goto <D.6404>; else goto <D.5471>;
    <D.6404>:
    D.6385 = sp->base;
    D.6377 = tbase + tsize;
    if (D.6385 != D.6377) goto <D.5469>; else goto <D.5471>;
    <D.5471>:
    if (sp != 0B) goto <D.6406>; else goto <D.6405>;
    <D.6406>:
    D.6391 = sp->sflags;
    D.6392 = D.6391 & 8;
    if (D.6392 == 0) goto <D.6407>; else goto <D.6405>;
    <D.6407>:
    D.6391 = sp->sflags;
    D.6394 = (long unsigned int) D.6391;
    D.6395 = D.6394 & 1;
    D.6396 = (long unsigned int) mmap_flag;
    if (D.6395 == D.6396) goto <D.6408>; else goto <D.6405>;
    <D.6408>:
    {
      char * oldbase;

      oldbase = sp->base;
      sp->base = tbase;
      D.6386 = sp->size;
      D.6400 = D.6386 + tsize;
      sp->size = D.6400;
      D.6272 = prepend_alloc (m, tbase, oldbase, nb);
      return D.6272;
    }
    <D.6405>:
    add_segment (m, tbase, tsize, mmap_flag);
    <D.6389>:
  }
  <D.6383>:
  D.6303 = m->topsize;
  if (D.6303 > nb) goto <D.6409>; else goto <D.6410>;
  <D.6409>:
  {
    size_t rsize;
    struct malloc_chunk * p;
    struct malloc_chunk * r;

    D.6303 = m->topsize;
    D.6411 = D.6303 - nb;
    m->topsize = D.6411;
    rsize = m->topsize;
    p = m->top;
    D.6412 = p + nb;
    m->top = D.6412;
    r = m->top;
    D.6413 = rsize | 1;
    r->head = D.6413;
    D.6414 = nb | 3;
    p->head = D.6414;
    D.6272 = p + 16;
    return D.6272;
  }
  <D.6410>:
  <D.6359>:
  D.6415 = __errno_location ();
  *D.6415 = 12;
  D.6272 = 0B;
  return D.6272;
}


mmap_alloc (struct malloc_state * m, size_t nb)
{
  long unsigned int D.6417;
  long unsigned int D.6418;
  long unsigned int D.6419;
  long unsigned int D.6420;
  long unsigned int iftmp.24;
  char * D.6426;
  long unsigned int D.6427;
  long unsigned int D.6428;
  long unsigned int D.6431;
  long unsigned int D.6433;
  long unsigned int D.6434;
  long unsigned int D.6435;
  struct malloc_chunk * D.6436;
  sizetype D.6437;
  struct malloc_chunk * D.6438;
  char * D.6439;
  long unsigned int D.6442;
  long unsigned int D.6443;
  long unsigned int D.6444;
  void * D.6447;
  size_t mmsize;

  D.6417 = mparams.granularity;
  D.6418 = D.6417 + nb;
  D.6419 = D.6418 + 55;
  D.6417 = mparams.granularity;
  D.6420 = -D.6417;
  mmsize = D.6419 & D.6420;
  if (mmsize > nb) goto <D.6421>; else goto <D.6422>;
  <D.6421>:
  {
    char * mm;

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

      D.6426 = mm + 16;
      D.6427 = (long unsigned int) D.6426;
      D.6428 = D.6427 & 7;
      if (D.6428 != 0) goto <D.6429>; else goto <D.6430>;
      <D.6429>:
      D.6426 = mm + 16;
      D.6427 = (long unsigned int) D.6426;
      D.6431 = -D.6427;
      iftmp.24 = D.6431 & 7;
      goto <D.6432>;
      <D.6430>:
      iftmp.24 = 0;
      <D.6432>:
      offset = iftmp.24;
      D.6433 = mmsize - offset;
      psize = D.6433 + 18446744073709551584;
      p = mm + offset;
      D.6434 = offset | 1;
      p->prev_foot = D.6434;
      D.6435 = psize | 2;
      p->head = D.6435;
      D.6436 = p + psize;
      D.6436->head = 11;
      D.6437 = psize + 8;
      D.6438 = p + D.6437;
      D.6438->head = 0;
      D.6439 = m->least_addr;
      if (D.6439 > mm) goto <D.6440>; else goto <D.6441>;
      <D.6440>:
      m->least_addr = mm;
      <D.6441>:
      D.6442 = m->footprint;
      D.6443 = D.6442 + mmsize;
      m->footprint = D.6443;
      D.6442 = m->footprint;
      D.6444 = m->max_footprint;
      if (D.6442 > D.6444) goto <D.6445>; else goto <D.6446>;
      <D.6445>:
      D.6442 = m->footprint;
      m->max_footprint = D.6442;
      <D.6446>:
      D.6447 = p + 16;
      return D.6447;
    }
    <D.6424>:
  }
  <D.6422>:
  D.6447 = 0B;
  return D.6447;
}


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

  i = 0;
  goto <D.5355>;
  <D.5354>:
  {
    struct malloc_chunk * bin;

    D.6449 = i << 1;
    bin = &m->smallbins[D.6449];
    bin->bk = bin;
    D.6450 = bin->bk;
    bin->fd = D.6450;
  }
  i = i + 1;
  <D.5355>:
  if (i <= 31) goto <D.5354>; else goto <D.5356>;
  <D.5356>:
}


init_top (struct malloc_state * m, struct malloc_chunk * p, size_t psize)
{
  long unsigned int iftmp.25;
  void * D.6452;
  long unsigned int D.6453;
  long unsigned int D.6454;
  long unsigned int D.6457;
  long unsigned int D.6459;
  struct malloc_chunk * D.6460;
  long unsigned int D.6461;
  size_t offset;

  D.6452 = p + 16;
  D.6453 = (long unsigned int) D.6452;
  D.6454 = D.6453 & 7;
  if (D.6454 != 0) goto <D.6455>; else goto <D.6456>;
  <D.6455>:
  D.6452 = p + 16;
  D.6453 = (long unsigned int) D.6452;
  D.6457 = -D.6453;
  iftmp.25 = D.6457 & 7;
  goto <D.6458>;
  <D.6456>:
  iftmp.25 = 0;
  <D.6458>:
  offset = iftmp.25;
  p = p + offset;
  psize = psize - offset;
  m->top = p;
  m->topsize = psize;
  D.6459 = psize | 1;
  p->head = D.6459;
  D.6460 = p + psize;
  D.6460->head = 72;
  D.6461 = mparams.trim_threshold;
  m->trim_check = D.6461;
}


prepend_alloc (struct malloc_state * m, char * newbase, char * oldbase, size_t nb)
{
  sizetype iftmp.26;
  char * D.6463;
  long unsigned int D.6464;
  long unsigned int D.6465;
  long unsigned int D.6468;
  sizetype iftmp.27;
  char * D.6471;
  long unsigned int D.6472;
  long unsigned int D.6473;
  long unsigned int D.6476;
  long int oldfirst.28;
  long int p.29;
  long int D.6480;
  long unsigned int D.6481;
  struct malloc_chunk * D.6482;
  long unsigned int D.6485;
  long unsigned int D.6486;
  long unsigned int D.6487;
  struct malloc_chunk * D.6489;
  long unsigned int D.6492;
  long unsigned int D.6493;
  long unsigned int D.6494;
  struct malloc_chunk * D.6495;
  long unsigned int D.6497;
  long unsigned int D.6498;
  long unsigned int D.6501;
  unsigned int D.6506;
  unsigned int D.6507;
  unsigned int D.6508;
  unsigned int D.6509;
  int iftmp.30;
  unsigned int D.6517;
  struct malloc_chunk * * D.6518;
  _Bool D.6519;
  long int D.6520;
  long int D.6521;
  char * D.6523;
  _Bool D.6524;
  long int D.6525;
  long int D.6526;
  int iftmp.31;
  _Bool D.6532;
  long int D.6533;
  long int D.6534;
  _Bool D.6536;
  long int D.6537;
  long int D.6538;
  struct malloc_tree_chunk * D.6541;
  _Bool D.6544;
  long int D.6545;
  long int D.6546;
  struct malloc_tree_chunk * D.6554;
  _Bool D.6556;
  long int D.6557;
  long int D.6558;
  unsigned int D.6564;
  struct malloc_tree_chunk * D.6565;
  unsigned int D.6570;
  unsigned int D.6571;
  unsigned int D.6572;
  unsigned int D.6573;
  _Bool D.6575;
  long int D.6576;
  long int D.6577;
  struct malloc_tree_chunk * D.6580;
  _Bool D.6587;
  long int D.6588;
  long int D.6589;
  _Bool D.6594;
  long int D.6595;
  long int D.6596;
  _Bool D.6602;
  long int D.6603;
  long int D.6604;
  long unsigned int D.6609;
  long unsigned int D.6610;
  struct malloc_chunk * D.6611;
  long unsigned int D.6612;
  unsigned int D.6615;
  unsigned int D.6616;
  unsigned int D.6617;
  unsigned int D.6620;
  struct malloc_chunk * D.6622;
  _Bool D.6623;
  long int D.6624;
  long int D.6625;
  unsigned int D.6636;
  unsigned int D.6637;
  unsigned int D.6638;
  unsigned int D.6639;
  unsigned int D.6640;
  unsigned int D.6641;
  unsigned int K.32;
  unsigned int D.6643;
  unsigned int D.6644;
  unsigned int D.6645;
  unsigned int D.6646;
  long unsigned int D.6647;
  unsigned int D.6648;
  unsigned int D.6649;
  struct malloc_tree_chunk * D.6650;
  unsigned int D.6651;
  unsigned int D.6652;
  unsigned int D.6655;
  struct malloc_tree_chunk * D.6656;
  unsigned int iftmp.33;
  unsigned int D.6661;
  long unsigned int D.6663;
  long unsigned int D.6664;
  long unsigned int D.6667;
  struct malloc_tree_chunk * D.6668;
  _Bool D.6672;
  long int D.6673;
  long int D.6674;
  _Bool D.6679;
  long int D.6680;
  long int D.6681;
  _Bool D.6683;
  long int D.6684;
  long int D.6685;
  struct malloc_tree_chunk * D.6687;
  void * D.6688;
  struct malloc_chunk * p;
  struct malloc_chunk * oldfirst;
  size_t psize;
  struct malloc_chunk * q;
  size_t qsize;

  D.6463 = newbase + 16;
  D.6464 = (long unsigned int) D.6463;
  D.6465 = D.6464 & 7;
  if (D.6465 != 0) goto <D.6466>; else goto <D.6467>;
  <D.6466>:
  D.6463 = newbase + 16;
  D.6464 = (long unsigned int) D.6463;
  D.6468 = -D.6464;
  iftmp.26 = D.6468 & 7;
  goto <D.6469>;
  <D.6467>:
  iftmp.26 = 0;
  <D.6469>:
  p = newbase + iftmp.26;
  D.6471 = oldbase + 16;
  D.6472 = (long unsigned int) D.6471;
  D.6473 = D.6472 & 7;
  if (D.6473 != 0) goto <D.6474>; else goto <D.6475>;
  <D.6474>:
  D.6471 = oldbase + 16;
  D.6472 = (long unsigned int) D.6471;
  D.6476 = -D.6472;
  iftmp.27 = D.6476 & 7;
  goto <D.6477>;
  <D.6475>:
  iftmp.27 = 0;
  <D.6477>:
  oldfirst = oldbase + iftmp.27;
  oldfirst.28 = (long int) oldfirst;
  p.29 = (long int) p;
  D.6480 = oldfirst.28 - p.29;
  psize = (size_t) D.6480;
  q = p + nb;
  qsize = psize - nb;
  D.6481 = nb | 3;
  p->head = D.6481;
  D.6482 = m->top;
  if (D.6482 == oldfirst) goto <D.6483>; else goto <D.6484>;
  <D.6483>:
  {
    size_t tsize;

    D.6485 = m->topsize;
    D.6486 = D.6485 + qsize;
    m->topsize = D.6486;
    tsize = m->topsize;
    m->top = q;
    D.6487 = tsize | 1;
    q->head = D.6487;
  }
  goto <D.6488>;
  <D.6484>:
  D.6489 = m->dv;
  if (D.6489 == oldfirst) goto <D.6490>; else goto <D.6491>;
  <D.6490>:
  {
    size_t dsize;

    D.6492 = m->dvsize;
    D.6493 = D.6492 + qsize;
    m->dvsize = D.6493;
    dsize = m->dvsize;
    m->dv = q;
    D.6494 = dsize | 1;
    q->head = D.6494;
    D.6495 = q + dsize;
    D.6495->prev_foot = dsize;
  }
  goto <D.6496>;
  <D.6491>:
  D.6497 = oldfirst->head;
  D.6498 = D.6497 & 2;
  if (D.6498 == 0) goto <D.6499>; else goto <D.6500>;
  <D.6499>:
  {
    size_t nsize;

    D.6497 = oldfirst->head;
    nsize = D.6497 & 18446744073709551612;
    D.6501 = nsize >> 3;
    if (D.6501 <= 31) goto <D.6502>; else goto <D.6503>;
    <D.6502>:
    {
      struct malloc_chunk * F;
      struct malloc_chunk * B;
      bindex_t I;

      F = oldfirst->fd;
      B = oldfirst->bk;
      D.6501 = nsize >> 3;
      I = (bindex_t) D.6501;
      if (F == B) goto <D.6504>; else goto <D.6505>;
      <D.6504>:
      D.6506 = m->smallmap;
      D.6507 = 1 << I;
      D.6508 = ~D.6507;
      D.6509 = D.6506 & D.6508;
      m->smallmap = D.6509;
      goto <D.6510>;
      <D.6505>:
      D.6517 = I << 1;
      D.6518 = &m->smallbins[D.6517];
      D.6519 = D.6518 == F;
      D.6520 = (long int) D.6519;
      D.6521 = __builtin_expect (D.6520, 1);
      if (D.6521 != 0) goto <D.6514>; else goto <D.6522>;
      <D.6522>:
      D.6523 = m->least_addr;
      D.6524 = D.6523 <= F;
      D.6525 = (long int) D.6524;
      D.6526 = __builtin_expect (D.6525, 1);
      if (D.6526 != 0) goto <D.6514>; else goto <D.6515>;
      <D.6514>:
      iftmp.30 = 1;
      goto <D.6516>;
      <D.6515>:
      iftmp.30 = 0;
      <D.6516>:
      if (iftmp.30 != 0) goto <D.6527>; else goto <D.6511>;
      <D.6527>:
      D.6517 = I << 1;
      D.6518 = &m->smallbins[D.6517];
      D.6532 = D.6518 == B;
      D.6533 = (long int) D.6532;
      D.6534 = __builtin_expect (D.6533, 1);
      if (D.6534 != 0) goto <D.6529>; else goto <D.6535>;
      <D.6535>:
      D.6523 = m->least_addr;
      D.6536 = D.6523 <= B;
      D.6537 = (long int) D.6536;
      D.6538 = __builtin_expect (D.6537, 1);
      if (D.6538 != 0) goto <D.6529>; else goto <D.6530>;
      <D.6529>:
      iftmp.31 = 1;
      goto <D.6531>;
      <D.6530>:
      iftmp.31 = 0;
      <D.6531>:
      if (iftmp.31 != 0) goto <D.6539>; else goto <D.6511>;
      <D.6539>:
      F->bk = B;
      B->fd = F;
      goto <D.6512>;
      <D.6511>:
      abort ();
      <D.6512>:
      <D.6510>:
    }
    goto <D.6540>;
    <D.6503>:
    {
      struct malloc_tree_chunk * TP;

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

        XP = TP->parent;
        D.6541 = TP->bk;
        if (D.6541 != TP) goto <D.6542>; else goto <D.6543>;
        <D.6542>:
        {
          struct malloc_tree_chunk * F;

          F = TP->fd;
          R = TP->bk;
          D.6523 = m->least_addr;
          D.6544 = D.6523 <= F;
          D.6545 = (long int) D.6544;
          D.6546 = __builtin_expect (D.6545, 1);
          if (D.6546 != 0) goto <D.6547>; else goto <D.6548>;
          <D.6547>:
          F->bk = R;
          R->fd = F;
          goto <D.6549>;
          <D.6548>:
          abort ();
          <D.6549>:
        }
        goto <D.6550>;
        <D.6543>:
        {
          struct malloc_tree_chunk * * RP;

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

            goto <D.5381>;
            <D.5380>:
            RP = CP;
            R = *RP;
            <D.5381>:
            CP = &R->child[1];
            D.6554 = *CP;
            if (D.6554 != 0B) goto <D.5380>; else goto <D.6555>;
            <D.6555>:
            CP = &R->child[0];
            D.6554 = *CP;
            if (D.6554 != 0B) goto <D.5380>; else goto <D.5382>;
            <D.5382>:
            D.6523 = m->least_addr;
            D.6556 = D.6523 <= RP;
            D.6557 = (long int) D.6556;
            D.6558 = __builtin_expect (D.6557, 1);
            if (D.6558 != 0) goto <D.6559>; else goto <D.6560>;
            <D.6559>:
            *RP = 0B;
            goto <D.6561>;
            <D.6560>:
            abort ();
            <D.6561>:
          }
          <D.6552>:
        }
        <D.6550>:
        if (XP != 0B) goto <D.6562>; else goto <D.6563>;
        <D.6562>:
        {
          struct malloc_tree_chunk * * H;

          D.6564 = TP->index;
          H = &m->treebins[D.6564];
          D.6565 = *H;
          if (D.6565 == TP) goto <D.6566>; else goto <D.6567>;
          <D.6566>:
          *H = R;
          D.6565 = *H;
          if (D.6565 == 0B) goto <D.6568>; else goto <D.6569>;
          <D.6568>:
          D.6570 = m->treemap;
          D.6564 = TP->index;
          D.6571 = 1 << D.6564;
          D.6572 = ~D.6571;
          D.6573 = D.6570 & D.6572;
          m->treemap = D.6573;
          <D.6569>:
          goto <D.6574>;
          <D.6567>:
          D.6523 = m->least_addr;
          D.6575 = D.6523 <= XP;
          D.6576 = (long int) D.6575;
          D.6577 = __builtin_expect (D.6576, 1);
          if (D.6577 != 0) goto <D.6578>; else goto <D.6579>;
          <D.6578>:
          D.6580 = XP->child[0];
          if (D.6580 == TP) goto <D.6581>; else goto <D.6582>;
          <D.6581>:
          XP->child[0] = R;
          goto <D.6583>;
          <D.6582>:
          XP->child[1] = R;
          <D.6583>:
          goto <D.6584>;
          <D.6579>:
          abort ();
          <D.6584>:
          <D.6574>:
          if (R != 0B) goto <D.6585>; else goto <D.6586>;
          <D.6585>:
          D.6523 = m->least_addr;
          D.6587 = D.6523 <= R;
          D.6588 = (long int) D.6587;
          D.6589 = __builtin_expect (D.6588, 1);
          if (D.6589 != 0) goto <D.6590>; else goto <D.6591>;
          <D.6590>:
          {
            struct malloc_tree_chunk * C0;
            struct malloc_tree_chunk * C1;

            R->parent = XP;
            C0 = TP->child[0];
            if (C0 != 0B) goto <D.6592>; else goto <D.6593>;
            <D.6592>:
            D.6523 = m->least_addr;
            D.6594 = D.6523 <= C0;
            D.6595 = (long int) D.6594;
            D.6596 = __builtin_expect (D.6595, 1);
            if (D.6596 != 0) goto <D.6597>; else goto <D.6598>;
            <D.6597>:
            R->child[0] = C0;
            C0->parent = R;
            goto <D.6599>;
            <D.6598>:
            abort ();
            <D.6599>:
            <D.6593>:
            C1 = TP->child[1];
            if (C1 != 0B) goto <D.6600>; else goto <D.6601>;
            <D.6600>:
            D.6523 = m->least_addr;
            D.6602 = D.6523 <= C1;
            D.6603 = (long int) D.6602;
            D.6604 = __builtin_expect (D.6603, 1);
            if (D.6604 != 0) goto <D.6605>; else goto <D.6606>;
            <D.6605>:
            R->child[1] = C1;
            C1->parent = R;
            goto <D.6607>;
            <D.6606>:
            abort ();
            <D.6607>:
            <D.6601>:
          }
          goto <D.6608>;
          <D.6591>:
          abort ();
          <D.6608>:
          <D.6586>:
        }
        <D.6563>:
      }
    }
    <D.6540>:
    oldfirst = oldfirst + nsize;
    qsize = qsize + nsize;
  }
  <D.6500>:
  D.6497 = oldfirst->head;
  D.6609 = D.6497 & 18446744073709551614;
  oldfirst->head = D.6609;
  D.6610 = qsize | 1;
  q->head = D.6610;
  D.6611 = q + qsize;
  D.6611->prev_foot = qsize;
  D.6612 = qsize >> 3;
  if (D.6612 <= 31) goto <D.6613>; else goto <D.6614>;
  <D.6613>:
  {
    bindex_t I;
    struct malloc_chunk * B;
    struct malloc_chunk * F;

    D.6612 = qsize >> 3;
    I = (bindex_t) D.6612;
    D.6615 = I << 1;
    B = &m->smallbins[D.6615];
    F = B;
    D.6506 = m->smallmap;
    D.6616 = 1 << I;
    D.6617 = D.6506 & D.6616;
    if (D.6617 == 0) goto <D.6618>; else goto <D.6619>;
    <D.6618>:
    D.6506 = m->smallmap;
    D.6616 = 1 << I;
    D.6620 = D.6506 | D.6616;
    m->smallmap = D.6620;
    goto <D.6621>;
    <D.6619>:
    D.6622 = B->fd;
    D.6523 = m->least_addr;
    D.6623 = D.6622 >= D.6523;
    D.6624 = (long int) D.6623;
    D.6625 = __builtin_expect (D.6624, 1);
    if (D.6625 != 0) goto <D.6626>; else goto <D.6627>;
    <D.6626>:
    F = B->fd;
    goto <D.6628>;
    <D.6627>:
    abort ();
    <D.6628>:
    <D.6621>:
    B->fd = q;
    F->bk = q;
    q->fd = F;
    q->bk = B;
  }
  goto <D.6629>;
  <D.6614>:
  {
    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.6630>; else goto <D.6631>;
        <D.6630>:
        I = 0;
        goto <D.6632>;
        <D.6631>:
        if (X > 65535) goto <D.6633>; else goto <D.6634>;
        <D.6633>:
        I = 31;
        goto <D.6635>;
        <D.6634>:
        {
          unsigned int Y;
          unsigned int N;
          unsigned int K;

          Y = (unsigned int) X;
          D.6636 = Y + 4294967040;
          D.6637 = D.6636 >> 16;
          N = D.6637 & 8;
          Y = Y << N;
          D.6638 = Y + 4294963200;
          D.6639 = D.6638 >> 16;
          K = D.6639 & 4;
          N = N + K;
          Y = Y << K;
          D.6640 = Y + 4294950912;
          D.6641 = D.6640 >> 16;
          K = D.6641 & 2;
          K.32 = K;
          N = K.32 + N;
          Y = Y << K;
          D.6643 = Y >> 15;
          D.6644 = D.6643 - N;
          K = D.6644 + 14;
          D.6645 = K << 1;
          D.6646 = K + 7;
          D.6647 = qsize >> D.6646;
          D.6648 = (unsigned int) D.6647;
          D.6649 = D.6648 & 1;
          I = D.6645 + D.6649;
        }
        <D.6635>:
        <D.6632>:
      }
      H = &m->treebins[I];
      TP->index = I;
      TP->child[1] = 0B;
      D.6650 = TP->child[1];
      TP->child[0] = D.6650;
      D.6570 = m->treemap;
      D.6651 = 1 << I;
      D.6652 = D.6570 & D.6651;
      if (D.6652 == 0) goto <D.6653>; else goto <D.6654>;
      <D.6653>:
      D.6570 = m->treemap;
      D.6651 = 1 << I;
      D.6655 = D.6570 | D.6651;
      m->treemap = D.6655;
      *H = TP;
      TP->parent = H;
      TP->bk = TP;
      D.6656 = TP->bk;
      TP->fd = D.6656;
      goto <D.6657>;
      <D.6654>:
      {
        struct malloc_tree_chunk * T;
        size_t K;

        T = *H;
        if (I != 31) goto <D.6659>; else goto <D.6660>;
        <D.6659>:
        D.6661 = I >> 1;
        iftmp.33 = 57 - D.6661;
        goto <D.6662>;
        <D.6660>:
        iftmp.33 = 0;
        <D.6662>:
        K = qsize << iftmp.33;
        <D.5401>:
        D.6663 = T->head;
        D.6664 = D.6663 & 18446744073709551612;
        if (D.6664 != qsize) goto <D.6665>; else goto <D.6666>;
        <D.6665>:
        {
          struct malloc_tree_chunk * * C;

          D.6667 = K >> 63;
          C = &T->child[D.6667];
          K = K << 1;
          D.6668 = *C;
          if (D.6668 != 0B) goto <D.6669>; else goto <D.6670>;
          <D.6669>:
          T = *C;
          goto <D.6671>;
          <D.6670>:
          D.6523 = m->least_addr;
          D.6672 = D.6523 <= C;
          D.6673 = (long int) D.6672;
          D.6674 = __builtin_expect (D.6673, 1);
          if (D.6674 != 0) goto <D.6675>; else goto <D.6676>;
          <D.6675>:
          *C = TP;
          TP->parent = T;
          TP->bk = TP;
          D.6656 = TP->bk;
          TP->fd = D.6656;
          goto <D.5399>;
          <D.6676>:
          abort ();
          <D.6671>:
        }
        goto <D.6677>;
        <D.6666>:
        {
          struct malloc_tree_chunk * F;

          F = T->fd;
          D.6523 = m->least_addr;
          D.6679 = D.6523 <= T;
          D.6680 = (long int) D.6679;
          D.6681 = __builtin_expect (D.6680, 1);
          if (D.6681 != 0) goto <D.6682>; else goto <D.6678>;
          <D.6682>:
          D.6523 = m->least_addr;
          D.6683 = D.6523 <= F;
          D.6684 = (long int) D.6683;
          D.6685 = __builtin_expect (D.6684, 1);
          if (D.6685 != 0) goto <D.6686>; else goto <D.6678>;
          <D.6686>:
          F->bk = TP;
          D.6687 = F->bk;
          T->fd = D.6687;
          TP->fd = F;
          TP->bk = T;
          TP->parent = 0B;
          goto <D.5399>;
          <D.6678>:
          abort ();
        }
        <D.6677>:
        goto <D.5401>;
        <D.5399>:
      }
      <D.6657>:
    }
  }
  <D.6629>:
  <D.6496>:
  <D.6488>:
  D.6688 = p + 16;
  return D.6688;
}


add_segment (struct malloc_state * m, char * tbase, size_t tsize, flag_t mmapped)
{
  char * D.6690;
  long unsigned int D.6691;
  sizetype D.6692;
  long unsigned int iftmp.34;
  char * D.6694;
  long unsigned int D.6695;
  long unsigned int D.6696;
  long unsigned int D.6699;
  char * iftmp.35;
  char * D.6702;
  long unsigned int D.6706;
  long unsigned int D.6707;
  size_t * D.6708;
  long int csp.36;
  long int old_top.37;
  long int D.6714;
  long unsigned int D.6715;
  long unsigned int D.6716;
  long unsigned int D.6717;
  struct malloc_chunk * D.6718;
  long unsigned int D.6719;
  unsigned int D.6722;
  unsigned int D.6723;
  unsigned int D.6724;
  unsigned int D.6725;
  unsigned int D.6728;
  struct malloc_chunk * D.6730;
  char * D.6731;
  _Bool D.6732;
  long int D.6733;
  long int D.6734;
  unsigned int D.6745;
  unsigned int D.6746;
  unsigned int D.6747;
  unsigned int D.6748;
  unsigned int D.6749;
  unsigned int D.6750;
  unsigned int K.38;
  unsigned int D.6752;
  unsigned int D.6753;
  unsigned int D.6754;
  unsigned int D.6755;
  long unsigned int D.6756;
  unsigned int D.6757;
  unsigned int D.6758;
  struct malloc_tree_chunk * D.6759;
  unsigned int D.6760;
  unsigned int D.6761;
  unsigned int D.6762;
  unsigned int D.6765;
  struct malloc_tree_chunk * D.6766;
  unsigned int iftmp.39;
  unsigned int D.6771;
  long unsigned int D.6773;
  long unsigned int D.6774;
  long unsigned int D.6777;
  struct malloc_tree_chunk * D.6778;
  _Bool D.6782;
  long int D.6783;
  long int D.6784;
  _Bool D.6789;
  long int D.6790;
  long int D.6791;
  _Bool D.6793;
  long int D.6794;
  long int D.6795;
  struct malloc_tree_chunk * D.6797;
  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.6690 = oldsp->base;
  D.6691 = oldsp->size;
  old_end = D.6690 + D.6691;
  ssize = 40;
  D.6692 = 18446744073709551577 - ssize;
  rawsp = old_end + D.6692;
  D.6694 = rawsp + 16;
  D.6695 = (long unsigned int) D.6694;
  D.6696 = D.6695 & 7;
  if (D.6696 != 0) goto <D.6697>; else goto <D.6698>;
  <D.6697>:
  D.6694 = rawsp + 16;
  D.6695 = (long unsigned int) D.6694;
  D.6699 = -D.6695;
  iftmp.34 = D.6699 & 7;
  goto <D.6700>;
  <D.6698>:
  iftmp.34 = 0;
  <D.6700>:
  offset = iftmp.34;
  asp = rawsp + offset;
  D.6702 = old_top + 32;
  if (D.6702 > asp) goto <D.6703>; else goto <D.6704>;
  <D.6703>:
  iftmp.35 = old_top;
  goto <D.6705>;
  <D.6704>:
  iftmp.35 = asp;
  <D.6705>:
  csp = iftmp.35;
  sp = csp;
  ss = sp + 16;
  tnext = sp + ssize;
  p = tnext;
  nfences = 0;
  D.6706 = tsize + 18446744073709551544;
  init_top (m, tbase, D.6706);
  D.6707 = ssize | 3;
  sp->head = D.6707;
  *ss = m->seg;
  m->seg.base = tbase;
  m->seg.size = tsize;
  m->seg.sflags = mmapped;
  m->seg.next = ss;
  <D.5423>:
  {
    struct malloc_chunk * nextp;

    nextp = p + 8;
    p->head = 11;
    nfences = nfences + 1;
    D.6708 = &nextp->head;
    if (D.6708 < old_end) goto <D.6709>; else goto <D.5422>;
    <D.6709>:
    p = nextp;
  }
  goto <D.5423>;
  <D.5422>:
  if (csp != old_top) goto <D.6710>; else goto <D.6711>;
  <D.6710>:
  {
    struct malloc_chunk * q;
    size_t psize;
    struct malloc_chunk * tn;

    q = old_top;
    csp.36 = (long int) csp;
    old_top.37 = (long int) old_top;
    D.6714 = csp.36 - old_top.37;
    psize = (size_t) D.6714;
    tn = q + psize;
    D.6715 = tn->head;
    D.6716 = D.6715 & 18446744073709551614;
    tn->head = D.6716;
    D.6717 = psize | 1;
    q->head = D.6717;
    D.6718 = q + psize;
    D.6718->prev_foot = psize;
    D.6719 = psize >> 3;
    if (D.6719 <= 31) goto <D.6720>; else goto <D.6721>;
    <D.6720>:
    {
      bindex_t I;
      struct malloc_chunk * B;
      struct malloc_chunk * F;

      D.6719 = psize >> 3;
      I = (bindex_t) D.6719;
      D.6722 = I << 1;
      B = &m->smallbins[D.6722];
      F = B;
      D.6723 = m->smallmap;
      D.6724 = 1 << I;
      D.6725 = D.6723 & D.6724;
      if (D.6725 == 0) goto <D.6726>; else goto <D.6727>;
      <D.6726>:
      D.6723 = m->smallmap;
      D.6724 = 1 << I;
      D.6728 = D.6723 | D.6724;
      m->smallmap = D.6728;
      goto <D.6729>;
      <D.6727>:
      D.6730 = B->fd;
      D.6731 = m->least_addr;
      D.6732 = D.6730 >= D.6731;
      D.6733 = (long int) D.6732;
      D.6734 = __builtin_expect (D.6733, 1);
      if (D.6734 != 0) goto <D.6735>; else goto <D.6736>;
      <D.6735>:
      F = B->fd;
      goto <D.6737>;
      <D.6736>:
      abort ();
      <D.6737>:
      <D.6729>:
      B->fd = q;
      F->bk = q;
      q->fd = F;
      q->bk = B;
    }
    goto <D.6738>;
    <D.6721>:
    {
      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.6739>; else goto <D.6740>;
          <D.6739>:
          I = 0;
          goto <D.6741>;
          <D.6740>:
          if (X > 65535) goto <D.6742>; else goto <D.6743>;
          <D.6742>:
          I = 31;
          goto <D.6744>;
          <D.6743>:
          {
            unsigned int Y;
            unsigned int N;
            unsigned int K;

            Y = (unsigned int) X;
            D.6745 = Y + 4294967040;
            D.6746 = D.6745 >> 16;
            N = D.6746 & 8;
            Y = Y << N;
            D.6747 = Y + 4294963200;
            D.6748 = D.6747 >> 16;
            K = D.6748 & 4;
            N = N + K;
            Y = Y << K;
            D.6749 = Y + 4294950912;
            D.6750 = D.6749 >> 16;
            K = D.6750 & 2;
            K.38 = K;
            N = K.38 + N;
            Y = Y << K;
            D.6752 = Y >> 15;
            D.6753 = D.6752 - N;
            K = D.6753 + 14;
            D.6754 = K << 1;
            D.6755 = K + 7;
            D.6756 = psize >> D.6755;
            D.6757 = (unsigned int) D.6756;
            D.6758 = D.6757 & 1;
            I = D.6754 + D.6758;
          }
          <D.6744>:
          <D.6741>:
        }
        H = &m->treebins[I];
        TP->index = I;
        TP->child[1] = 0B;
        D.6759 = TP->child[1];
        TP->child[0] = D.6759;
        D.6760 = m->treemap;
        D.6761 = 1 << I;
        D.6762 = D.6760 & D.6761;
        if (D.6762 == 0) goto <D.6763>; else goto <D.6764>;
        <D.6763>:
        D.6760 = m->treemap;
        D.6761 = 1 << I;
        D.6765 = D.6760 | D.6761;
        m->treemap = D.6765;
        *H = TP;
        TP->parent = H;
        TP->bk = TP;
        D.6766 = TP->bk;
        TP->fd = D.6766;
        goto <D.6767>;
        <D.6764>:
        {
          struct malloc_tree_chunk * T;
          size_t K;

          T = *H;
          if (I != 31) goto <D.6769>; else goto <D.6770>;
          <D.6769>:
          D.6771 = I >> 1;
          iftmp.39 = 57 - D.6771;
          goto <D.6772>;
          <D.6770>:
          iftmp.39 = 0;
          <D.6772>:
          K = psize << iftmp.39;
          <D.5442>:
          D.6773 = T->head;
          D.6774 = D.6773 & 18446744073709551612;
          if (D.6774 != psize) goto <D.6775>; else goto <D.6776>;
          <D.6775>:
          {
            struct malloc_tree_chunk * * C;

            D.6777 = K >> 63;
            C = &T->child[D.6777];
            K = K << 1;
            D.6778 = *C;
            if (D.6778 != 0B) goto <D.6779>; else goto <D.6780>;
            <D.6779>:
            T = *C;
            goto <D.6781>;
            <D.6780>:
            D.6731 = m->least_addr;
            D.6782 = D.6731 <= C;
            D.6783 = (long int) D.6782;
            D.6784 = __builtin_expect (D.6783, 1);
            if (D.6784 != 0) goto <D.6785>; else goto <D.6786>;
            <D.6785>:
            *C = TP;
            TP->parent = T;
            TP->bk = TP;
            D.6766 = TP->bk;
            TP->fd = D.6766;
            goto <D.5440>;
            <D.6786>:
            abort ();
            <D.6781>:
          }
          goto <D.6787>;
          <D.6776>:
          {
            struct malloc_tree_chunk * F;

            F = T->fd;
            D.6731 = m->least_addr;
            D.6789 = D.6731 <= T;
            D.6790 = (long int) D.6789;
            D.6791 = __builtin_expect (D.6790, 1);
            if (D.6791 != 0) goto <D.6792>; else goto <D.6788>;
            <D.6792>:
            D.6731 = m->least_addr;
            D.6793 = D.6731 <= F;
            D.6794 = (long int) D.6793;
            D.6795 = __builtin_expect (D.6794, 1);
            if (D.6795 != 0) goto <D.6796>; else goto <D.6788>;
            <D.6796>:
            F->bk = TP;
            D.6797 = F->bk;
            T->fd = D.6797;
            TP->fd = F;
            TP->bk = T;
            TP->parent = 0B;
            goto <D.5440>;
            <D.6788>:
            abort ();
          }
          <D.6787>:
          goto <D.5442>;
          <D.5440>:
        }
        <D.6767>:
      }
    }
    <D.6738>:
  }
  <D.6711>:
}


segment_holding (struct malloc_state * m, char * addr)
{
  char * D.6798;
  long unsigned int D.6801;
  char * D.6802;
  struct malloc_segment * D.6805;
  struct malloc_segment * sp;

  sp = &m->seg;
  <D.5323>:
  D.6798 = sp->base;
  if (D.6798 <= addr) goto <D.6799>; else goto <D.6800>;
  <D.6799>:
  D.6798 = sp->base;
  D.6801 = sp->size;
  D.6802 = D.6798 + D.6801;
  if (D.6802 > addr) goto <D.6803>; else goto <D.6804>;
  <D.6803>:
  D.6805 = sp;
  return D.6805;
  <D.6804>:
  <D.6800>:
  sp = sp->next;
  if (sp == 0B) goto <D.6806>; else goto <D.6807>;
  <D.6806>:
  D.6805 = 0B;
  return D.6805;
  <D.6807>:
  goto <D.5323>;
}


dlfree (void * mem)
{
  long unsigned int D.6815;
  int D.6817;
  unsigned int D.6818;
  unsigned int D.6819;
  int D.6820;
  char * D.6821;
  _Bool D.6822;
  long int D.6823;
  long int D.6824;
  long unsigned int D.6827;
  long unsigned int D.6828;
  _Bool D.6829;
  long int D.6830;
  long int D.6831;
  long unsigned int D.6834;
  long unsigned int D.6837;
  long unsigned int D.6840;
  sizetype D.6841;
  void * D.6842;
  int D.6843;
  long unsigned int D.6846;
  long unsigned int D.6847;
  _Bool D.6848;
  long int D.6849;
  long int D.6850;
  struct malloc_chunk * D.6852;
  long unsigned int D.6855;
  unsigned int D.6860;
  unsigned int D.6861;
  unsigned int D.6862;
  unsigned int D.6863;
  int iftmp.40;
  unsigned int D.6871;
  struct malloc_chunk * * D.6872;
  _Bool D.6873;
  long int D.6874;
  long int D.6875;
  _Bool D.6877;
  long int D.6878;
  long int D.6879;
  int iftmp.41;
  _Bool D.6885;
  long int D.6886;
  long int D.6887;
  _Bool D.6889;
  long int D.6890;
  long int D.6891;
  struct malloc_tree_chunk * D.6894;
  _Bool D.6897;
  long int D.6898;
  long int D.6899;
  struct malloc_tree_chunk * D.6907;
  _Bool D.6909;
  long int D.6910;
  long int D.6911;
  unsigned int D.6917;
  struct malloc_tree_chunk * D.6918;
  unsigned int D.6923;
  unsigned int D.6924;
  unsigned int D.6925;
  unsigned int D.6926;
  _Bool D.6928;
  long int D.6929;
  long int D.6930;
  struct malloc_tree_chunk * D.6933;
  _Bool D.6940;
  long int D.6941;
  long int D.6942;
  _Bool D.6947;
  long int D.6948;
  long int D.6949;
  _Bool D.6955;
  long int D.6956;
  long int D.6957;
  long unsigned int D.6963;
  long unsigned int D.6964;
  long unsigned int D.6967;
  long unsigned int D.6968;
  struct malloc_chunk * D.6969;
  _Bool D.6970;
  long int D.6971;
  long int D.6972;
  long unsigned int D.6975;
  _Bool D.6976;
  long int D.6977;
  long int D.6978;
  long unsigned int D.6981;
  struct malloc_chunk * D.6984;
  long unsigned int D.6987;
  long unsigned int D.6988;
  long unsigned int D.6989;
  long unsigned int D.6992;
  long unsigned int D.6997;
  long unsigned int D.6998;
  long unsigned int D.6999;
  struct malloc_chunk * D.7000;
  long unsigned int D.7001;
  unsigned int D.7006;
  unsigned int D.7007;
  unsigned int D.7008;
  int iftmp.42;
  unsigned int D.7016;
  struct malloc_chunk * * D.7017;
  _Bool D.7018;
  long int D.7019;
  long int D.7020;
  _Bool D.7022;
  long int D.7023;
  long int D.7024;
  int iftmp.43;
  _Bool D.7030;
  long int D.7031;
  long int D.7032;
  _Bool D.7034;
  long int D.7035;
  long int D.7036;
  struct malloc_tree_chunk * D.7039;
  _Bool D.7042;
  long int D.7043;
  long int D.7044;
  struct malloc_tree_chunk * D.7052;
  _Bool D.7054;
  long int D.7055;
  long int D.7056;
  unsigned int D.7062;
  struct malloc_tree_chunk * D.7063;
  unsigned int D.7068;
  unsigned int D.7069;
  unsigned int D.7070;
  _Bool D.7072;
  long int D.7073;
  long int D.7074;
  struct malloc_tree_chunk * D.7077;
  _Bool D.7084;
  long int D.7085;
  long int D.7086;
  _Bool D.7091;
  long int D.7092;
  long int D.7093;
  _Bool D.7099;
  long int D.7100;
  long int D.7101;
  long unsigned int D.7109;
  unsigned int D.7112;
  unsigned int D.7113;
  unsigned int D.7114;
  unsigned int D.7117;
  struct malloc_chunk * D.7119;
  _Bool D.7120;
  long int D.7121;
  long int D.7122;
  unsigned int D.7133;
  unsigned int D.7134;
  unsigned int D.7135;
  unsigned int D.7136;
  unsigned int D.7137;
  unsigned int D.7138;
  unsigned int K.44;
  unsigned int D.7140;
  unsigned int D.7141;
  unsigned int D.7142;
  unsigned int D.7143;
  long unsigned int D.7144;
  unsigned int D.7145;
  unsigned int D.7146;
  struct malloc_tree_chunk * D.7147;
  unsigned int D.7148;
  unsigned int D.7149;
  unsigned int D.7152;
  struct malloc_tree_chunk * D.7153;
  unsigned int iftmp.45;
  unsigned int D.7158;
  long unsigned int D.7160;
  long unsigned int D.7161;
  long unsigned int D.7164;
  struct malloc_tree_chunk * D.7165;
  _Bool D.7169;
  long int D.7170;
  long int D.7171;
  _Bool D.7176;
  long int D.7177;
  long int D.7178;
  _Bool D.7180;
  long int D.7181;
  long int D.7182;
  struct malloc_tree_chunk * D.7184;
  void postaction = <<< error >>>;
  void erroraction = <<< error >>>;

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

    p = mem + 18446744073709551600;
    D.6815 = mparams.page_size;
    if (D.6815 != 0) goto <D.6811>; else goto <D.6816>;
    <D.6816>:
    D.6817 = init_mparams ();
    if (D.6817 == 0) goto <D.6811>; else goto <D.6812>;
    <D.6811>:
    D.6818 = _gm_.mflags;
    D.6819 = D.6818 & 2;
    if (D.6819 == 0) goto <D.6813>; else goto <D.6812>;
    <D.6812>:
    D.6820 = pthread_mutex_lock (&_gm_.mutex);
    if (D.6820 == 0) goto <D.6813>; else goto <D.6814>;
    <D.6813>:
    D.6821 = _gm_.least_addr;
    D.6822 = D.6821 <= p;
    D.6823 = (long int) D.6822;
    D.6824 = __builtin_expect (D.6823, 1);
    if (D.6824 != 0) goto <D.6825>; else goto <D.6826>;
    <D.6825>:
    D.6827 = p->head;
    D.6828 = D.6827 & 2;
    D.6829 = D.6828 != 0;
    D.6830 = (long int) D.6829;
    D.6831 = __builtin_expect (D.6830, 1);
    if (D.6831 != 0) goto <D.6832>; else goto <D.6833>;
    <D.6832>:
    {
      size_t psize;
      struct malloc_chunk * next;

      D.6827 = p->head;
      psize = D.6827 & 18446744073709551612;
      next = p + psize;
      D.6827 = p->head;
      D.6834 = D.6827 & 1;
      if (D.6834 == 0) goto <D.6835>; else goto <D.6836>;
      <D.6835>:
      {
        size_t prevsize;

        prevsize = p->prev_foot;
        D.6837 = prevsize & 1;
        if (D.6837 != 0) goto <D.6838>; else goto <D.6839>;
        <D.6838>:
        prevsize = prevsize & 18446744073709551614;
        D.6840 = prevsize + psize;
        psize = D.6840 + 32;
        D.6841 = -prevsize;
        D.6842 = p + D.6841;
        D.6843 = munmap (D.6842, psize);
        if (D.6843 == 0) goto <D.6844>; else goto <D.6845>;
        <D.6844>:
        D.6846 = _gm_.footprint;
        D.6847 = D.6846 - psize;
        _gm_.footprint = D.6847;
        <D.6845>:
        goto postaction;
        <D.6839>:
        {
          struct malloc_chunk * prev;

          D.6841 = -prevsize;
          prev = p + D.6841;
          psize = psize + prevsize;
          p = prev;
          D.6821 = _gm_.least_addr;
          D.6848 = D.6821 <= prev;
          D.6849 = (long int) D.6848;
          D.6850 = __builtin_expect (D.6849, 1);
          if (D.6850 != 0) goto <D.6851>; else goto erroraction;
          <D.6851>:
          D.6852 = _gm_.dv;
          if (D.6852 != p) goto <D.6853>; else goto <D.6854>;
          <D.6853>:
          D.6855 = prevsize >> 3;
          if (D.6855 <= 31) goto <D.6856>; else goto <D.6857>;
          <D.6856>:
          {
            struct malloc_chunk * F;
            struct malloc_chunk * B;
            bindex_t I;

            F = p->fd;
            B = p->bk;
            D.6855 = prevsize >> 3;
            I = (bindex_t) D.6855;
            if (F == B) goto <D.6858>; else goto <D.6859>;
            <D.6858>:
            D.6860 = _gm_.smallmap;
            D.6861 = 1 << I;
            D.6862 = ~D.6861;
            D.6863 = D.6860 & D.6862;
            _gm_.smallmap = D.6863;
            goto <D.6864>;
            <D.6859>:
            D.6871 = I << 1;
            D.6872 = &_gm_.smallbins[D.6871];
            D.6873 = D.6872 == F;
            D.6874 = (long int) D.6873;
            D.6875 = __builtin_expect (D.6874, 1);
            if (D.6875 != 0) goto <D.6868>; else goto <D.6876>;
            <D.6876>:
            D.6821 = _gm_.least_addr;
            D.6877 = D.6821 <= F;
            D.6878 = (long int) D.6877;
            D.6879 = __builtin_expect (D.6878, 1);
            if (D.6879 != 0) goto <D.6868>; else goto <D.6869>;
            <D.6868>:
            iftmp.40 = 1;
            goto <D.6870>;
            <D.6869>:
            iftmp.40 = 0;
            <D.6870>:
            if (iftmp.40 != 0) goto <D.6880>; else goto <D.6865>;
            <D.6880>:
            D.6871 = I << 1;
            D.6872 = &_gm_.smallbins[D.6871];
            D.6885 = D.6872 == B;
            D.6886 = (long int) D.6885;
            D.6887 = __builtin_expect (D.6886, 1);
            if (D.6887 != 0) goto <D.6882>; else goto <D.6888>;
            <D.6888>:
            D.6821 = _gm_.least_addr;
            D.6889 = D.6821 <= B;
            D.6890 = (long int) D.6889;
            D.6891 = __builtin_expect (D.6890, 1);
            if (D.6891 != 0) goto <D.6882>; else goto <D.6883>;
            <D.6882>:
            iftmp.41 = 1;
            goto <D.6884>;
            <D.6883>:
            iftmp.41 = 0;
            <D.6884>:
            if (iftmp.41 != 0) goto <D.6892>; else goto <D.6865>;
            <D.6892>:
            F->bk = B;
            B->fd = F;
            goto <D.6866>;
            <D.6865>:
            abort ();
            <D.6866>:
            <D.6864>:
          }
          goto <D.6893>;
          <D.6857>:
          {
            struct malloc_tree_chunk * TP;

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

              XP = TP->parent;
              D.6894 = TP->bk;
              if (D.6894 != TP) goto <D.6895>; else goto <D.6896>;
              <D.6895>:
              {
                struct malloc_tree_chunk * F;

                F = TP->fd;
                R = TP->bk;
                D.6821 = _gm_.least_addr;
                D.6897 = D.6821 <= F;
                D.6898 = (long int) D.6897;
                D.6899 = __builtin_expect (D.6898, 1);
                if (D.6899 != 0) goto <D.6900>; else goto <D.6901>;
                <D.6900>:
                F->bk = R;
                R->fd = F;
                goto <D.6902>;
                <D.6901>:
                abort ();
                <D.6902>:
              }
              goto <D.6903>;
              <D.6896>:
              {
                struct malloc_tree_chunk * * RP;

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

                  goto <D.5691>;
                  <D.5690>:
                  RP = CP;
                  R = *RP;
                  <D.5691>:
                  CP = &R->child[1];
                  D.6907 = *CP;
                  if (D.6907 != 0B) goto <D.5690>; else goto <D.6908>;
                  <D.6908>:
                  CP = &R->child[0];
                  D.6907 = *CP;
                  if (D.6907 != 0B) goto <D.5690>; else goto <D.5692>;
                  <D.5692>:
                  D.6821 = _gm_.least_addr;
                  D.6909 = D.6821 <= RP;
                  D.6910 = (long int) D.6909;
                  D.6911 = __builtin_expect (D.6910, 1);
                  if (D.6911 != 0) goto <D.6912>; else goto <D.6913>;
                  <D.6912>:
                  *RP = 0B;
                  goto <D.6914>;
                  <D.6913>:
                  abort ();
                  <D.6914>:
                }
                <D.6905>:
              }
              <D.6903>:
              if (XP != 0B) goto <D.6915>; else goto <D.6916>;
              <D.6915>:
              {
                struct malloc_tree_chunk * * H;

                D.6917 = TP->index;
                H = &_gm_.treebins[D.6917];
                D.6918 = *H;
                if (D.6918 == TP) goto <D.6919>; else goto <D.6920>;
                <D.6919>:
                *H = R;
                D.6918 = *H;
                if (D.6918 == 0B) goto <D.6921>; else goto <D.6922>;
                <D.6921>:
                D.6923 = _gm_.treemap;
                D.6917 = TP->index;
                D.6924 = 1 << D.6917;
                D.6925 = ~D.6924;
                D.6926 = D.6923 & D.6925;
                _gm_.treemap = D.6926;
                <D.6922>:
                goto <D.6927>;
                <D.6920>:
                D.6821 = _gm_.least_addr;
                D.6928 = D.6821 <= XP;
                D.6929 = (long int) D.6928;
                D.6930 = __builtin_expect (D.6929, 1);
                if (D.6930 != 0) goto <D.6931>; else goto <D.6932>;
                <D.6931>:
                D.6933 = XP->child[0];
                if (D.6933 == TP) goto <D.6934>; else goto <D.6935>;
                <D.6934>:
                XP->child[0] = R;
                goto <D.6936>;
                <D.6935>:
                XP->child[1] = R;
                <D.6936>:
                goto <D.6937>;
                <D.6932>:
                abort ();
                <D.6937>:
                <D.6927>:
                if (R != 0B) goto <D.6938>; else goto <D.6939>;
                <D.6938>:
                D.6821 = _gm_.least_addr;
                D.6940 = D.6821 <= R;
                D.6941 = (long int) D.6940;
                D.6942 = __builtin_expect (D.6941, 1);
                if (D.6942 != 0) goto <D.6943>; else goto <D.6944>;
                <D.6943>:
                {
                  struct malloc_tree_chunk * C0;
                  struct malloc_tree_chunk * C1;

                  R->parent = XP;
                  C0 = TP->child[0];
                  if (C0 != 0B) goto <D.6945>; else goto <D.6946>;
                  <D.6945>:
                  D.6821 = _gm_.least_addr;
                  D.6947 = D.6821 <= C0;
                  D.6948 = (long int) D.6947;
                  D.6949 = __builtin_expect (D.6948, 1);
                  if (D.6949 != 0) goto <D.6950>; else goto <D.6951>;
                  <D.6950>:
                  R->child[0] = C0;
                  C0->parent = R;
                  goto <D.6952>;
                  <D.6951>:
                  abort ();
                  <D.6952>:
                  <D.6946>:
                  C1 = TP->child[1];
                  if (C1 != 0B) goto <D.6953>; else goto <D.6954>;
                  <D.6953>:
                  D.6821 = _gm_.least_addr;
                  D.6955 = D.6821 <= C1;
                  D.6956 = (long int) D.6955;
                  D.6957 = __builtin_expect (D.6956, 1);
                  if (D.6957 != 0) goto <D.6958>; else goto <D.6959>;
                  <D.6958>:
                  R->child[1] = C1;
                  C1->parent = R;
                  goto <D.6960>;
                  <D.6959>:
                  abort ();
                  <D.6960>:
                  <D.6954>:
                }
                goto <D.6961>;
                <D.6944>:
                abort ();
                <D.6961>:
                <D.6939>:
              }
              <D.6916>:
            }
          }
          <D.6893>:
          goto <D.6962>;
          <D.6854>:
          D.6963 = next->head;
          D.6964 = D.6963 & 3;
          if (D.6964 == 3) goto <D.6965>; else goto <D.6966>;
          <D.6965>:
          _gm_.dvsize = psize;
          D.6963 = next->head;
          D.6967 = D.6963 & 18446744073709551614;
          next->head = D.6967;
          D.6968 = psize | 1;
          p->head = D.6968;
          D.6969 = p + psize;
          D.6969->prev_foot = psize;
          goto postaction;
          <D.6966>:
          <D.6962>:
        }
      }
      <D.6836>:
      D.6970 = p < next;
      D.6971 = (long int) D.6970;
      D.6972 = __builtin_expect (D.6971, 1);
      if (D.6972 != 0) goto <D.6973>; else goto <D.6974>;
      <D.6973>:
      D.6963 = next->head;
      D.6975 = D.6963 & 1;
      D.6976 = D.6975 != 0;
      D.6977 = (long int) D.6976;
      D.6978 = __builtin_expect (D.6977, 1);
      if (D.6978 != 0) goto <D.6979>; else goto <D.6980>;
      <D.6979>:
      D.6963 = next->head;
      D.6981 = D.6963 & 2;
      if (D.6981 == 0) goto <D.6982>; else goto <D.6983>;
      <D.6982>:
      D.6984 = _gm_.top;
      if (D.6984 == next) goto <D.6985>; else goto <D.6986>;
      <D.6985>:
      {
        size_t tsize;

        D.6987 = _gm_.topsize;
        D.6988 = D.6987 + psize;
        _gm_.topsize = D.6988;
        tsize = _gm_.topsize;
        _gm_.top = p;
        D.6989 = tsize | 1;
        p->head = D.6989;
        D.6852 = _gm_.dv;
        if (D.6852 == p) goto <D.6990>; else goto <D.6991>;
        <D.6990>:
        _gm_.dv = 0B;
        _gm_.dvsize = 0;
        <D.6991>:
        D.6992 = _gm_.trim_check;
        if (D.6992 < tsize) goto <D.6993>; else goto <D.6994>;
        <D.6993>:
        sys_trim (&_gm_, 0);
        <D.6994>:
        goto postaction;
      }
      <D.6986>:
      D.6852 = _gm_.dv;
      if (D.6852 == next) goto <D.6995>; else goto <D.6996>;
      <D.6995>:
      {
        size_t dsize;

        D.6997 = _gm_.dvsize;
        D.6998 = D.6997 + psize;
        _gm_.dvsize = D.6998;
        dsize = _gm_.dvsize;
        _gm_.dv = p;
        D.6999 = dsize | 1;
        p->head = D.6999;
        D.7000 = p + dsize;
        D.7000->prev_foot = dsize;
        goto postaction;
      }
      <D.6996>:
      {
        size_t nsize;

        D.6963 = next->head;
        nsize = D.6963 & 18446744073709551612;
        psize = psize + nsize;
        D.7001 = nsize >> 3;
        if (D.7001 <= 31) goto <D.7002>; else goto <D.7003>;
        <D.7002>:
        {
          struct malloc_chunk * F;
          struct malloc_chunk * B;
          bindex_t I;

          F = next->fd;
          B = next->bk;
          D.7001 = nsize >> 3;
          I = (bindex_t) D.7001;
          if (F == B) goto <D.7004>; else goto <D.7005>;
          <D.7004>:
          D.6860 = _gm_.smallmap;
          D.7006 = 1 << I;
          D.7007 = ~D.7006;
          D.7008 = D.6860 & D.7007;
          _gm_.smallmap = D.7008;
          goto <D.7009>;
          <D.7005>:
          D.7016 = I << 1;
          D.7017 = &_gm_.smallbins[D.7016];
          D.7018 = D.7017 == F;
          D.7019 = (long int) D.7018;
          D.7020 = __builtin_expect (D.7019, 1);
          if (D.7020 != 0) goto <D.7013>; else goto <D.7021>;
          <D.7021>:
          D.6821 = _gm_.least_addr;
          D.7022 = D.6821 <= F;
          D.7023 = (long int) D.7022;
          D.7024 = __builtin_expect (D.7023, 1);
          if (D.7024 != 0) goto <D.7013>; else goto <D.7014>;
          <D.7013>:
          iftmp.42 = 1;
          goto <D.7015>;
          <D.7014>:
          iftmp.42 = 0;
          <D.7015>:
          if (iftmp.42 != 0) goto <D.7025>; else goto <D.7010>;
          <D.7025>:
          D.7016 = I << 1;
          D.7017 = &_gm_.smallbins[D.7016];
          D.7030 = D.7017 == B;
          D.7031 = (long int) D.7030;
          D.7032 = __builtin_expect (D.7031, 1);
          if (D.7032 != 0) goto <D.7027>; else goto <D.7033>;
          <D.7033>:
          D.6821 = _gm_.least_addr;
          D.7034 = D.6821 <= B;
          D.7035 = (long int) D.7034;
          D.7036 = __builtin_expect (D.7035, 1);
          if (D.7036 != 0) goto <D.7027>; else goto <D.7028>;
          <D.7027>:
          iftmp.43 = 1;
          goto <D.7029>;
          <D.7028>:
          iftmp.43 = 0;
          <D.7029>:
          if (iftmp.43 != 0) goto <D.7037>; else goto <D.7010>;
          <D.7037>:
          F->bk = B;
          B->fd = F;
          goto <D.7011>;
          <D.7010>:
          abort ();
          <D.7011>:
          <D.7009>:
        }
        goto <D.7038>;
        <D.7003>:
        {
          struct malloc_tree_chunk * TP;

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

            XP = TP->parent;
            D.7039 = TP->bk;
            if (D.7039 != TP) goto <D.7040>; else goto <D.7041>;
            <D.7040>:
            {
              struct malloc_tree_chunk * F;

              F = TP->fd;
              R = TP->bk;
              D.6821 = _gm_.least_addr;
              D.7042 = D.6821 <= F;
              D.7043 = (long int) D.7042;
              D.7044 = __builtin_expect (D.7043, 1);
              if (D.7044 != 0) goto <D.7045>; else goto <D.7046>;
              <D.7045>:
              F->bk = R;
              R->fd = F;
              goto <D.7047>;
              <D.7046>:
              abort ();
              <D.7047>:
            }
            goto <D.7048>;
            <D.7041>:
            {
              struct malloc_tree_chunk * * RP;

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

                goto <D.5710>;
                <D.5709>:
                RP = CP;
                R = *RP;
                <D.5710>:
                CP = &R->child[1];
                D.7052 = *CP;
                if (D.7052 != 0B) goto <D.5709>; else goto <D.7053>;
                <D.7053>:
                CP = &R->child[0];
                D.7052 = *CP;
                if (D.7052 != 0B) goto <D.5709>; else goto <D.5711>;
                <D.5711>:
                D.6821 = _gm_.least_addr;
                D.7054 = D.6821 <= RP;
                D.7055 = (long int) D.7054;
                D.7056 = __builtin_expect (D.7055, 1);
                if (D.7056 != 0) goto <D.7057>; else goto <D.7058>;
                <D.7057>:
                *RP = 0B;
                goto <D.7059>;
                <D.7058>:
                abort ();
                <D.7059>:
              }
              <D.7050>:
            }
            <D.7048>:
            if (XP != 0B) goto <D.7060>; else goto <D.7061>;
            <D.7060>:
            {
              struct malloc_tree_chunk * * H;

              D.7062 = TP->index;
              H = &_gm_.treebins[D.7062];
              D.7063 = *H;
              if (D.7063 == TP) goto <D.7064>; else goto <D.7065>;
              <D.7064>:
              *H = R;
              D.7063 = *H;
              if (D.7063 == 0B) goto <D.7066>; else goto <D.7067>;
              <D.7066>:
              D.6923 = _gm_.treemap;
              D.7062 = TP->index;
              D.7068 = 1 << D.7062;
              D.7069 = ~D.7068;
              D.7070 = D.6923 & D.7069;
              _gm_.treemap = D.7070;
              <D.7067>:
              goto <D.7071>;
              <D.7065>:
              D.6821 = _gm_.least_addr;
              D.7072 = D.6821 <= XP;
              D.7073 = (long int) D.7072;
              D.7074 = __builtin_expect (D.7073, 1);
              if (D.7074 != 0) goto <D.7075>; else goto <D.7076>;
              <D.7075>:
              D.7077 = XP->child[0];
              if (D.7077 == TP) goto <D.7078>; else goto <D.7079>;
              <D.7078>:
              XP->child[0] = R;
              goto <D.7080>;
              <D.7079>:
              XP->child[1] = R;
              <D.7080>:
              goto <D.7081>;
              <D.7076>:
              abort ();
              <D.7081>:
              <D.7071>:
              if (R != 0B) goto <D.7082>; else goto <D.7083>;
              <D.7082>:
              D.6821 = _gm_.least_addr;
              D.7084 = D.6821 <= R;
              D.7085 = (long int) D.7084;
              D.7086 = __builtin_expect (D.7085, 1);
              if (D.7086 != 0) goto <D.7087>; else goto <D.7088>;
              <D.7087>:
              {
                struct malloc_tree_chunk * C0;
                struct malloc_tree_chunk * C1;

                R->parent = XP;
                C0 = TP->child[0];
                if (C0 != 0B) goto <D.7089>; else goto <D.7090>;
                <D.7089>:
                D.6821 = _gm_.least_addr;
                D.7091 = D.6821 <= C0;
                D.7092 = (long int) D.7091;
                D.7093 = __builtin_expect (D.7092, 1);
                if (D.7093 != 0) goto <D.7094>; else goto <D.7095>;
                <D.7094>:
                R->child[0] = C0;
                C0->parent = R;
                goto <D.7096>;
                <D.7095>:
                abort ();
                <D.7096>:
                <D.7090>:
                C1 = TP->child[1];
                if (C1 != 0B) goto <D.7097>; else goto <D.7098>;
                <D.7097>:
                D.6821 = _gm_.least_addr;
                D.7099 = D.6821 <= C1;
                D.7100 = (long int) D.7099;
                D.7101 = __builtin_expect (D.7100, 1);
                if (D.7101 != 0) goto <D.7102>; else goto <D.7103>;
                <D.7102>:
                R->child[1] = C1;
                C1->parent = R;
                goto <D.7104>;
                <D.7103>:
                abort ();
                <D.7104>:
                <D.7098>:
              }
              goto <D.7105>;
              <D.7088>:
              abort ();
              <D.7105>:
              <D.7083>:
            }
            <D.7061>:
          }
        }
        <D.7038>:
        D.6968 = psize | 1;
        p->head = D.6968;
        D.6969 = p + psize;
        D.6969->prev_foot = psize;
        D.6852 = _gm_.dv;
        if (D.6852 == p) goto <D.7106>; else goto <D.7107>;
        <D.7106>:
        _gm_.dvsize = psize;
        goto postaction;
        <D.7107>:
      }
      goto <D.7108>;
      <D.6983>:
      D.6963 = next->head;
      D.6967 = D.6963 & 18446744073709551614;
      next->head = D.6967;
      D.6968 = psize | 1;
      p->head = D.6968;
      D.6969 = p + psize;
      D.6969->prev_foot = psize;
      <D.7108>:
      D.7109 = psize >> 3;
      if (D.7109 <= 31) goto <D.7110>; else goto <D.7111>;
      <D.7110>:
      {
        bindex_t I;
        struct malloc_chunk * B;
        struct malloc_chunk * F;

        D.7109 = psize >> 3;
        I = (bindex_t) D.7109;
        D.7112 = I << 1;
        B = &_gm_.smallbins[D.7112];
        F = B;
        D.6860 = _gm_.smallmap;
        D.7113 = 1 << I;
        D.7114 = D.6860 & D.7113;
        if (D.7114 == 0) goto <D.7115>; else goto <D.7116>;
        <D.7115>:
        D.6860 = _gm_.smallmap;
        D.7113 = 1 << I;
        D.7117 = D.6860 | D.7113;
        _gm_.smallmap = D.7117;
        goto <D.7118>;
        <D.7116>:
        D.7119 = B->fd;
        D.6821 = _gm_.least_addr;
        D.7120 = D.7119 >= D.6821;
        D.7121 = (long int) D.7120;
        D.7122 = __builtin_expect (D.7121, 1);
        if (D.7122 != 0) goto <D.7123>; else goto <D.7124>;
        <D.7123>:
        F = B->fd;
        goto <D.7125>;
        <D.7124>:
        abort ();
        <D.7125>:
        <D.7118>:
        B->fd = p;
        F->bk = p;
        p->fd = F;
        p->bk = B;
      }
      goto <D.7126>;
      <D.7111>:
      {
        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.7127>; else goto <D.7128>;
            <D.7127>:
            I = 0;
            goto <D.7129>;
            <D.7128>:
            if (X > 65535) goto <D.7130>; else goto <D.7131>;
            <D.7130>:
            I = 31;
            goto <D.7132>;
            <D.7131>:
            {
              unsigned int Y;
              unsigned int N;
              unsigned int K;

              Y = (unsigned int) X;
              D.7133 = Y + 4294967040;
              D.7134 = D.7133 >> 16;
              N = D.7134 & 8;
              Y = Y << N;
              D.7135 = Y + 4294963200;
              D.7136 = D.7135 >> 16;
              K = D.7136 & 4;
              N = N + K;
              Y = Y << K;
              D.7137 = Y + 4294950912;
              D.7138 = D.7137 >> 16;
              K = D.7138 & 2;
              K.44 = K;
              N = K.44 + N;
              Y = Y << K;
              D.7140 = Y >> 15;
              D.7141 = D.7140 - N;
              K = D.7141 + 14;
              D.7142 = K << 1;
              D.7143 = K + 7;
              D.7144 = psize >> D.7143;
              D.7145 = (unsigned int) D.7144;
              D.7146 = D.7145 & 1;
              I = D.7142 + D.7146;
            }
            <D.7132>:
            <D.7129>:
          }
          H = &_gm_.treebins[I];
          TP->index = I;
          TP->child[1] = 0B;
          D.7147 = TP->child[1];
          TP->child[0] = D.7147;
          D.6923 = _gm_.treemap;
          D.7148 = 1 << I;
          D.7149 = D.6923 & D.7148;
          if (D.7149 == 0) goto <D.7150>; else goto <D.7151>;
          <D.7150>:
          D.6923 = _gm_.treemap;
          D.7148 = 1 << I;
          D.7152 = D.6923 | D.7148;
          _gm_.treemap = D.7152;
          *H = TP;
          TP->parent = H;
          TP->bk = TP;
          D.7153 = TP->bk;
          TP->fd = D.7153;
          goto <D.7154>;
          <D.7151>:
          {
            struct malloc_tree_chunk * T;
            size_t K;

            T = *H;
            if (I != 31) goto <D.7156>; else goto <D.7157>;
            <D.7156>:
            D.7158 = I >> 1;
            iftmp.45 = 57 - D.7158;
            goto <D.7159>;
            <D.7157>:
            iftmp.45 = 0;
            <D.7159>:
            K = psize << iftmp.45;
            <D.5730>:
            D.7160 = T->head;
            D.7161 = D.7160 & 18446744073709551612;
            if (D.7161 != psize) goto <D.7162>; else goto <D.7163>;
            <D.7162>:
            {
              struct malloc_tree_chunk * * C;

              D.7164 = K >> 63;
              C = &T->child[D.7164];
              K = K << 1;
              D.7165 = *C;
              if (D.7165 != 0B) goto <D.7166>; else goto <D.7167>;
              <D.7166>:
              T = *C;
              goto <D.7168>;
              <D.7167>:
              D.6821 = _gm_.least_addr;
              D.7169 = D.6821 <= C;
              D.7170 = (long int) D.7169;
              D.7171 = __builtin_expect (D.7170, 1);
              if (D.7171 != 0) goto <D.7172>; else goto <D.7173>;
              <D.7172>:
              *C = TP;
              TP->parent = T;
              TP->bk = TP;
              D.7153 = TP->bk;
              TP->fd = D.7153;
              goto <D.5728>;
              <D.7173>:
              abort ();
              <D.7168>:
            }
            goto <D.7174>;
            <D.7163>:
            {
              struct malloc_tree_chunk * F;

              F = T->fd;
              D.6821 = _gm_.least_addr;
              D.7176 = D.6821 <= T;
              D.7177 = (long int) D.7176;
              D.7178 = __builtin_expect (D.7177, 1);
              if (D.7178 != 0) goto <D.7179>; else goto <D.7175>;
              <D.7179>:
              D.6821 = _gm_.least_addr;
              D.7180 = D.6821 <= F;
              D.7181 = (long int) D.7180;
              D.7182 = __builtin_expect (D.7181, 1);
              if (D.7182 != 0) goto <D.7183>; else goto <D.7175>;
              <D.7183>:
              F->bk = TP;
              D.7184 = F->bk;
              T->fd = D.7184;
              TP->fd = F;
              TP->bk = T;
              TP->parent = 0B;
              goto <D.5728>;
              <D.7175>:
              abort ();
            }
            <D.7174>:
            goto <D.5730>;
            <D.5728>:
          }
          <D.7154>:
        }
      }
      <D.7126>:
      goto postaction;
      <D.6980>:
      <D.6974>:
    }
    <D.6833>:
    <D.6826>:
    erroraction:
    abort ();
    postaction:
    D.6818 = _gm_.mflags;
    D.6819 = D.6818 & 2;
    if (D.6819 != 0) goto <D.7185>; else goto <D.7186>;
    <D.7185>:
    pthread_mutex_unlock (&_gm_.mutex);
    <D.7186>:
    <D.6814>:
  }
  <D.6810>:
}


sys_trim (struct malloc_state * m, size_t pad)
{
  struct malloc_chunk * D.7189;
  long unsigned int D.7192;
  long unsigned int D.7195;
  long unsigned int D.7196;
  long unsigned int D.7197;
  long unsigned int D.7198;
  long unsigned int D.7199;
  unsigned int D.7200;
  unsigned int D.7201;
  long unsigned int D.7204;
  long unsigned int D.7205;
  long unsigned int D.7208;
  int D.7211;
  char * D.7216;
  void * D.7217;
  char * D.7219;
  int D.7220;
  char * D.7226;
  long int old_br.46;
  long int new_br.47;
  long int D.7235;
  long unsigned int D.7238;
  long unsigned int D.7239;
  long unsigned int D.7240;
  long unsigned int D.7241;
  long unsigned int D.7244;
  int D.7247;
  _Bool D.7248;
  size_t released;

  released = 0;
  if (pad <= 18446744073709551487) goto <D.7187>; else goto <D.7188>;
  <D.7187>:
  D.7189 = m->top;
  if (D.7189 != 0B) goto <D.7190>; else goto <D.7191>;
  <D.7190>:
  pad = pad + 72;
  D.7192 = m->topsize;
  if (D.7192 > pad) goto <D.7193>; else goto <D.7194>;
  <D.7193>:
  {
    size_t unit;
    size_t extra;
    struct malloc_segment * sp;

    unit = mparams.granularity;
    D.7192 = m->topsize;
    D.7195 = D.7192 - pad;
    D.7196 = D.7195 + unit;
    D.7197 = D.7196 + 18446744073709551615;
    D.7198 = D.7197 / unit;
    D.7199 = D.7198 + 18446744073709551615;
    extra = D.7199 * unit;
    D.7189 = m->top;
    sp = segment_holding (m, D.7189);
    D.7200 = sp->sflags;
    D.7201 = D.7200 & 8;
    if (D.7201 == 0) goto <D.7202>; else goto <D.7203>;
    <D.7202>:
    D.7200 = sp->sflags;
    D.7204 = (long unsigned int) D.7200;
    D.7205 = D.7204 & 1;
    if (D.7205 != 0) goto <D.7206>; else goto <D.7207>;
    <D.7206>:
    D.7208 = sp->size;
    if (D.7208 >= extra) goto <D.7209>; else goto <D.7210>;
    <D.7209>:
    D.7211 = has_segment_link (m, sp);
    if (D.7211 == 0) goto <D.7212>; else goto <D.7213>;
    <D.7212>:
    {
      size_t newsize;

      D.7208 = sp->size;
      newsize = D.7208 - extra;
      D.7216 = sp->base;
      D.7208 = sp->size;
      D.7217 = mremap (D.7216, D.7208, newsize, 0);
      if (D.7217 != -1B) goto <D.7214>; else goto <D.7218>;
      <D.7218>:
      D.7216 = sp->base;
      D.7219 = D.7216 + newsize;
      D.7220 = munmap (D.7219, extra);
      if (D.7220 == 0) goto <D.7214>; else goto <D.7215>;
      <D.7214>:
      released = extra;
      <D.7215>:
    }
    <D.7213>:
    <D.7210>:
    goto <D.7221>;
    <D.7207>:
    if (0 != 0) goto <D.7222>; else goto <D.7223>;
    <D.7222>:
    if (extra > 9223372036854775806) goto <D.7224>; else goto <D.7225>;
    <D.7224>:
    extra = 9223372036854775808 - unit;
    <D.7225>:
    {
      char * old_br;

      old_br = -1B;
      D.7216 = sp->base;
      D.7208 = sp->size;
      D.7226 = D.7216 + D.7208;
      if (D.7226 == old_br) goto <D.7227>; else goto <D.7228>;
      <D.7227>:
      {
        char * rel_br;
        char * new_br;

        rel_br = -1B;
        new_br = -1B;
        if (rel_br != -1B) goto <D.7229>; else goto <D.7230>;
        <D.7229>:
        if (new_br < old_br) goto <D.7231>; else goto <D.7232>;
        <D.7231>:
        old_br.46 = (long int) old_br;
        new_br.47 = (long int) new_br;
        D.7235 = old_br.46 - new_br.47;
        released = (size_t) D.7235;
        <D.7232>:
        <D.7230>:
      }
      <D.7228>:
    }
    <D.7223>:
    <D.7221>:
    <D.7203>:
    if (released != 0) goto <D.7236>; else goto <D.7237>;
    <D.7236>:
    D.7208 = sp->size;
    D.7238 = D.7208 - released;
    sp->size = D.7238;
    D.7239 = m->footprint;
    D.7240 = D.7239 - released;
    m->footprint = D.7240;
    D.7189 = m->top;
    D.7192 = m->topsize;
    D.7241 = D.7192 - released;
    init_top (m, D.7189, D.7241);
    <D.7237>:
  }
  <D.7194>:
  if (1 != 0) goto <D.7242>; else goto <D.7243>;
  <D.7242>:
  D.7244 = release_unused_segments (m);
  released = D.7244 + released;
  <D.7243>:
  if (released == 0) goto <D.7245>; else goto <D.7246>;
  <D.7245>:
  m->trim_check = 18446744073709551615;
  <D.7246>:
  <D.7191>:
  <D.7188>:
  D.7248 = released != 0;
  D.7247 = (int) D.7248;
  return D.7247;
}


has_segment_link (struct malloc_state * m, struct malloc_segment * ss)
{
  char * D.7250;
  long unsigned int D.7253;
  char * D.7254;
  int D.7257;
  struct malloc_segment * sp;

  sp = &m->seg;
  <D.5329>:
  D.7250 = ss->base;
  if (D.7250 <= sp) goto <D.7251>; else goto <D.7252>;
  <D.7251>:
  D.7250 = ss->base;
  D.7253 = ss->size;
  D.7254 = D.7250 + D.7253;
  if (D.7254 > sp) goto <D.7255>; else goto <D.7256>;
  <D.7255>:
  D.7257 = 1;
  return D.7257;
  <D.7256>:
  <D.7252>:
  sp = sp->next;
  if (sp == 0B) goto <D.7258>; else goto <D.7259>;
  <D.7258>:
  D.7257 = 0;
  return D.7257;
  <D.7259>:
  goto <D.5329>;
}


release_unused_segments (struct malloc_state * m)
{
  unsigned int D.7261;
  long unsigned int D.7262;
  long unsigned int D.7263;
  unsigned int D.7266;
  sizetype iftmp.48;
  char * D.7270;
  long unsigned int D.7271;
  long unsigned int D.7272;
  long unsigned int D.7275;
  long unsigned int D.7277;
  long unsigned int D.7278;
  char * D.7281;
  sizetype D.7282;
  char * D.7283;
  struct malloc_chunk * D.7286;
  struct malloc_tree_chunk * D.7290;
  char * D.7293;
  _Bool D.7294;
  long int D.7295;
  long int D.7296;
  struct malloc_tree_chunk * D.7304;
  _Bool D.7306;
  long int D.7307;
  long int D.7308;
  unsigned int D.7314;
  struct malloc_tree_chunk * D.7315;
  unsigned int D.7320;
  unsigned int D.7321;
  unsigned int D.7322;
  unsigned int D.7323;
  _Bool D.7325;
  long int D.7326;
  long int D.7327;
  struct malloc_tree_chunk * D.7330;
  _Bool D.7337;
  long int D.7338;
  long int D.7339;
  _Bool D.7344;
  long int D.7345;
  long int D.7346;
  _Bool D.7352;
  long int D.7353;
  long int D.7354;
  int D.7359;
  long unsigned int D.7362;
  long unsigned int D.7363;
  unsigned int D.7371;
  unsigned int D.7372;
  unsigned int D.7373;
  unsigned int D.7374;
  unsigned int D.7375;
  unsigned int D.7376;
  unsigned int K.49;
  unsigned int D.7378;
  unsigned int D.7379;
  unsigned int D.7380;
  unsigned int D.7381;
  long unsigned int D.7382;
  unsigned int D.7383;
  unsigned int D.7384;
  struct malloc_tree_chunk * D.7385;
  unsigned int D.7386;
  unsigned int D.7387;
  unsigned int D.7390;
  unsigned int iftmp.50;
  unsigned int D.7395;
  long unsigned int D.7397;
  long unsigned int D.7398;
  long unsigned int D.7401;
  struct malloc_tree_chunk * D.7402;
  _Bool D.7406;
  long int D.7407;
  long int D.7408;
  _Bool D.7413;
  long int D.7414;
  long int D.7415;
  _Bool D.7417;
  long int D.7418;
  long int D.7419;
  struct malloc_tree_chunk * D.7421;
  size_t D.7422;
  size_t released;
  struct malloc_segment * pred;
  struct malloc_segment * sp;

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

    base = sp->base;
    size = sp->size;
    next = sp->next;
    D.7261 = sp->sflags;
    D.7262 = (long unsigned int) D.7261;
    D.7263 = D.7262 & 1;
    if (D.7263 != 0) goto <D.7264>; else goto <D.7265>;
    <D.7264>:
    D.7261 = sp->sflags;
    D.7266 = D.7261 & 8;
    if (D.7266 == 0) goto <D.7267>; else goto <D.7268>;
    <D.7267>:
    {
      struct malloc_chunk * p;
      size_t psize;

      D.7270 = base + 16;
      D.7271 = (long unsigned int) D.7270;
      D.7272 = D.7271 & 7;
      if (D.7272 != 0) goto <D.7273>; else goto <D.7274>;
      <D.7273>:
      D.7270 = base + 16;
      D.7271 = (long unsigned int) D.7270;
      D.7275 = -D.7271;
      iftmp.48 = D.7275 & 7;
      goto <D.7276>;
      <D.7274>:
      iftmp.48 = 0;
      <D.7276>:
      p = base + iftmp.48;
      D.7277 = p->head;
      psize = D.7277 & 18446744073709551612;
      D.7277 = p->head;
      D.7278 = D.7277 & 2;
      if (D.7278 == 0) goto <D.7279>; else goto <D.7280>;
      <D.7279>:
      D.7281 = p + psize;
      D.7282 = size + 18446744073709551544;
      D.7283 = base + D.7282;
      if (D.7281 >= D.7283) goto <D.7284>; else goto <D.7285>;
      <D.7284>:
      {
        struct malloc_tree_chunk * tp;

        tp = p;
        D.7286 = m->dv;
        if (D.7286 == p) goto <D.7287>; else goto <D.7288>;
        <D.7287>:
        m->dv = 0B;
        m->dvsize = 0;
        goto <D.7289>;
        <D.7288>:
        {
          struct malloc_tree_chunk * XP;
          struct malloc_tree_chunk * R;

          XP = tp->parent;
          D.7290 = tp->bk;
          if (D.7290 != tp) goto <D.7291>; else goto <D.7292>;
          <D.7291>:
          {
            struct malloc_tree_chunk * F;

            F = tp->fd;
            R = tp->bk;
            D.7293 = m->least_addr;
            D.7294 = D.7293 <= F;
            D.7295 = (long int) D.7294;
            D.7296 = __builtin_expect (D.7295, 1);
            if (D.7296 != 0) goto <D.7297>; else goto <D.7298>;
            <D.7297>:
            F->bk = R;
            R->fd = F;
            goto <D.7299>;
            <D.7298>:
            abort ();
            <D.7299>:
          }
          goto <D.7300>;
          <D.7292>:
          {
            struct malloc_tree_chunk * * RP;

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

              goto <D.5494>;
              <D.5493>:
              RP = CP;
              R = *RP;
              <D.5494>:
              CP = &R->child[1];
              D.7304 = *CP;
              if (D.7304 != 0B) goto <D.5493>; else goto <D.7305>;
              <D.7305>:
              CP = &R->child[0];
              D.7304 = *CP;
              if (D.7304 != 0B) goto <D.5493>; else goto <D.5495>;
              <D.5495>:
              D.7293 = m->least_addr;
              D.7306 = D.7293 <= RP;
              D.7307 = (long int) D.7306;
              D.7308 = __builtin_expect (D.7307, 1);
              if (D.7308 != 0) goto <D.7309>; else goto <D.7310>;
              <D.7309>:
              *RP = 0B;
              goto <D.7311>;
              <D.7310>:
              abort ();
              <D.7311>:
            }
            <D.7302>:
          }
          <D.7300>:
          if (XP != 0B) goto <D.7312>; else goto <D.7313>;
          <D.7312>:
          {
            struct malloc_tree_chunk * * H;

            D.7314 = tp->index;
            H = &m->treebins[D.7314];
            D.7315 = *H;
            if (D.7315 == tp) goto <D.7316>; else goto <D.7317>;
            <D.7316>:
            *H = R;
            D.7315 = *H;
            if (D.7315 == 0B) goto <D.7318>; else goto <D.7319>;
            <D.7318>:
            D.7320 = m->treemap;
            D.7314 = tp->index;
            D.7321 = 1 << D.7314;
            D.7322 = ~D.7321;
            D.7323 = D.7320 & D.7322;
            m->treemap = D.7323;
            <D.7319>:
            goto <D.7324>;
            <D.7317>:
            D.7293 = m->least_addr;
            D.7325 = D.7293 <= XP;
            D.7326 = (long int) D.7325;
            D.7327 = __builtin_expect (D.7326, 1);
            if (D.7327 != 0) goto <D.7328>; else goto <D.7329>;
            <D.7328>:
            D.7330 = XP->child[0];
            if (D.7330 == tp) goto <D.7331>; else goto <D.7332>;
            <D.7331>:
            XP->child[0] = R;
            goto <D.7333>;
            <D.7332>:
            XP->child[1] = R;
            <D.7333>:
            goto <D.7334>;
            <D.7329>:
            abort ();
            <D.7334>:
            <D.7324>:
            if (R != 0B) goto <D.7335>; else goto <D.7336>;
            <D.7335>:
            D.7293 = m->least_addr;
            D.7337 = D.7293 <= R;
            D.7338 = (long int) D.7337;
            D.7339 = __builtin_expect (D.7338, 1);
            if (D.7339 != 0) goto <D.7340>; else goto <D.7341>;
            <D.7340>:
            {
              struct malloc_tree_chunk * C0;
              struct malloc_tree_chunk * C1;

              R->parent = XP;
              C0 = tp->child[0];
              if (C0 != 0B) goto <D.7342>; else goto <D.7343>;
              <D.7342>:
              D.7293 = m->least_addr;
              D.7344 = D.7293 <= C0;
              D.7345 = (long int) D.7344;
              D.7346 = __builtin_expect (D.7345, 1);
              if (D.7346 != 0) goto <D.7347>; else goto <D.7348>;
              <D.7347>:
              R->child[0] = C0;
              C0->parent = R;
              goto <D.7349>;
              <D.7348>:
              abort ();
              <D.7349>:
              <D.7343>:
              C1 = tp->child[1];
              if (C1 != 0B) goto <D.7350>; else goto <D.7351>;
              <D.7350>:
              D.7293 = m->least_addr;
              D.7352 = D.7293 <= C1;
              D.7353 = (long int) D.7352;
              D.7354 = __builtin_expect (D.7353, 1);
              if (D.7354 != 0) goto <D.7355>; else goto <D.7356>;
              <D.7355>:
              R->child[1] = C1;
              C1->parent = R;
              goto <D.7357>;
              <D.7356>:
              abort ();
              <D.7357>:
              <D.7351>:
            }
            goto <D.7358>;
            <D.7341>:
            abort ();
            <D.7358>:
            <D.7336>:
          }
          <D.7313>:
        }
        <D.7289>:
        D.7359 = munmap (base, size);
        if (D.7359 == 0) goto <D.7360>; else goto <D.7361>;
        <D.7360>:
        released = released + size;
        D.7362 = m->footprint;
        D.7363 = D.7362 - size;
        m->footprint = D.7363;
        sp = pred;
        sp->next = next;
        goto <D.7364>;
        <D.7361>:
        {
          struct malloc_tree_chunk * * H;
          bindex_t I;

          {
            size_t X;

            X = psize >> 8;
            if (X == 0) goto <D.7365>; else goto <D.7366>;
            <D.7365>:
            I = 0;
            goto <D.7367>;
            <D.7366>:
            if (X > 65535) goto <D.7368>; else goto <D.7369>;
            <D.7368>:
            I = 31;
            goto <D.7370>;
            <D.7369>:
            {
              unsigned int Y;
              unsigned int N;
              unsigned int K;

              Y = (unsigned int) X;
              D.7371 = Y + 4294967040;
              D.7372 = D.7371 >> 16;
              N = D.7372 & 8;
              Y = Y << N;
              D.7373 = Y + 4294963200;
              D.7374 = D.7373 >> 16;
              K = D.7374 & 4;
              N = N + K;
              Y = Y << K;
              D.7375 = Y + 4294950912;
              D.7376 = D.7375 >> 16;
              K = D.7376 & 2;
              K.49 = K;
              N = K.49 + N;
              Y = Y << K;
              D.7378 = Y >> 15;
              D.7379 = D.7378 - N;
              K = D.7379 + 14;
              D.7380 = K << 1;
              D.7381 = K + 7;
              D.7382 = psize >> D.7381;
              D.7383 = (unsigned int) D.7382;
              D.7384 = D.7383 & 1;
              I = D.7380 + D.7384;
            }
            <D.7370>:
            <D.7367>:
          }
          H = &m->treebins[I];
          tp->index = I;
          tp->child[1] = 0B;
          D.7385 = tp->child[1];
          tp->child[0] = D.7385;
          D.7320 = m->treemap;
          D.7386 = 1 << I;
          D.7387 = D.7320 & D.7386;
          if (D.7387 == 0) goto <D.7388>; else goto <D.7389>;
          <D.7388>:
          D.7320 = m->treemap;
          D.7386 = 1 << I;
          D.7390 = D.7320 | D.7386;
          m->treemap = D.7390;
          *H = tp;
          tp->parent = H;
          tp->bk = tp;
          D.7290 = tp->bk;
          tp->fd = D.7290;
          goto <D.7391>;
          <D.7389>:
          {
            struct malloc_tree_chunk * T;
            size_t K;

            T = *H;
            if (I != 31) goto <D.7393>; else goto <D.7394>;
            <D.7393>:
            D.7395 = I >> 1;
            iftmp.50 = 57 - D.7395;
            goto <D.7396>;
            <D.7394>:
            iftmp.50 = 0;
            <D.7396>:
            K = psize << iftmp.50;
            <D.5510>:
            D.7397 = T->head;
            D.7398 = D.7397 & 18446744073709551612;
            if (D.7398 != psize) goto <D.7399>; else goto <D.7400>;
            <D.7399>:
            {
              struct malloc_tree_chunk * * C;

              D.7401 = K >> 63;
              C = &T->child[D.7401];
              K = K << 1;
              D.7402 = *C;
              if (D.7402 != 0B) goto <D.7403>; else goto <D.7404>;
              <D.7403>:
              T = *C;
              goto <D.7405>;
              <D.7404>:
              D.7293 = m->least_addr;
              D.7406 = D.7293 <= C;
              D.7407 = (long int) D.7406;
              D.7408 = __builtin_expect (D.7407, 1);
              if (D.7408 != 0) goto <D.7409>; else goto <D.7410>;
              <D.7409>:
              *C = tp;
              tp->parent = T;
              tp->bk = tp;
              D.7290 = tp->bk;
              tp->fd = D.7290;
              goto <D.5508>;
              <D.7410>:
              abort ();
              <D.7405>:
            }
            goto <D.7411>;
            <D.7400>:
            {
              struct malloc_tree_chunk * F;

              F = T->fd;
              D.7293 = m->least_addr;
              D.7413 = D.7293 <= T;
              D.7414 = (long int) D.7413;
              D.7415 = __builtin_expect (D.7414, 1);
              if (D.7415 != 0) goto <D.7416>; else goto <D.7412>;
              <D.7416>:
              D.7293 = m->least_addr;
              D.7417 = D.7293 <= F;
              D.7418 = (long int) D.7417;
              D.7419 = __builtin_expect (D.7418, 1);
              if (D.7419 != 0) goto <D.7420>; else goto <D.7412>;
              <D.7420>:
              F->bk = tp;
              D.7421 = F->bk;
              T->fd = D.7421;
              tp->fd = F;
              tp->bk = T;
              tp->parent = 0B;
              goto <D.5508>;
              <D.7412>:
              abort ();
            }
            <D.7411>:
            goto <D.5510>;
            <D.5508>:
          }
          <D.7391>:
        }
        <D.7364>:
      }
      <D.7285>:
      <D.7280>:
    }
    <D.7268>:
    <D.7265>:
    pred = sp;
    sp = next;
  }
  <D.5512>:
  if (sp != 0B) goto <D.5511>; else goto <D.5513>;
  <D.5513>:
  D.7422 = released;
  return D.7422;
}


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

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


internal_memalign (struct malloc_state * m, size_t alignment, size_t bytes)
{
  void * D.7428;
  long unsigned int D.7431;
  long unsigned int D.7432;
  long unsigned int D.7435;
  int * D.7440;
  long unsigned int iftmp.51;
  long unsigned int D.7445;
  long unsigned int D.7447;
  long unsigned int D.7453;
  int D.7455;
  unsigned int D.7456;
  unsigned int D.7457;
  union pthread_mutex_t * D.7458;
  int D.7459;
  long unsigned int mem.52;
  long unsigned int D.7463;
  sizetype D.7466;
  char * D.7467;
  long unsigned int D.7468;
  long unsigned int D.7469;
  long unsigned int D.7470;
  sizetype D.7471;
  char * iftmp.53;
  long int br.54;
  long int p.55;
  long int D.7475;
  long unsigned int D.7476;
  long int pos.56;
  long int D.7481;
  long unsigned int D.7482;
  long unsigned int D.7483;
  long unsigned int D.7486;
  long unsigned int D.7488;
  long unsigned int D.7489;
  long unsigned int D.7491;
  long unsigned int D.7492;
  long unsigned int D.7493;
  long unsigned int D.7494;
  long unsigned int D.7495;
  long unsigned int D.7496;
  struct malloc_chunk * D.7497;
  long unsigned int D.7498;
  long unsigned int D.7499;
  long unsigned int D.7500;
  long unsigned int D.7501;
  struct malloc_chunk * D.7502;
  long unsigned int D.7503;
  long unsigned int D.7504;
  long unsigned int D.7508;
  long unsigned int D.7511;
  long unsigned int D.7512;
  struct malloc_chunk * D.7513;
  long unsigned int D.7514;
  long unsigned int D.7515;
  long unsigned int D.7516;
  long unsigned int D.7517;
  long unsigned int D.7518;
  long unsigned int D.7519;
  struct malloc_chunk * D.7520;
  long unsigned int D.7521;
  long unsigned int D.7522;

  if (alignment <= 8) goto <D.7426>; else goto <D.7427>;
  <D.7426>:
  D.7428 = dlmalloc (bytes);
  return D.7428;
  <D.7427>:
  if (alignment <= 31) goto <D.7429>; else goto <D.7430>;
  <D.7429>:
  alignment = 32;
  <D.7430>:
  D.7431 = alignment + 18446744073709551615;
  D.7432 = D.7431 & alignment;
  if (D.7432 != 0) goto <D.7433>; else goto <D.7434>;
  <D.7433>:
  {
    size_t a;

    a = 16;
    goto <D.5622>;
    <D.5621>:
    a = a << 1;
    <D.5622>:
    if (a < alignment) goto <D.5621>; else goto <D.5623>;
    <D.5623>:
    alignment = a;
  }
  <D.7434>:
  D.7435 = 18446744073709551488 - alignment;
  if (D.7435 <= bytes) goto <D.7436>; else goto <D.7437>;
  <D.7436>:
  if (m != 0B) goto <D.7438>; else goto <D.7439>;
  <D.7438>:
  D.7440 = __errno_location ();
  *D.7440 = 12;
  <D.7439>:
  goto <D.7441>;
  <D.7437>:
  {
    size_t nb;
    size_t req;
    char * mem;

    if (bytes > 22) goto <D.7443>; else goto <D.7444>;
    <D.7443>:
    D.7445 = bytes + 15;
    iftmp.51 = D.7445 & 18446744073709551608;
    goto <D.7446>;
    <D.7444>:
    iftmp.51 = 32;
    <D.7446>:
    nb = iftmp.51;
    D.7447 = nb + alignment;
    req = D.7447 + 24;
    mem = dlmalloc (req);
    if (mem != 0B) goto <D.7448>; else goto <D.7449>;
    <D.7448>:
    {
      void * leader;
      void * trailer;
      struct malloc_chunk * p;

      leader = 0B;
      trailer = 0B;
      p = mem + 18446744073709551600;
      D.7453 = mparams.page_size;
      if (D.7453 == 0) goto <D.7454>; else goto <D.7450>;
      <D.7454>:
      D.7455 = init_mparams ();
      if (D.7455 != 0) goto <D.7451>; else goto <D.7450>;
      <D.7450>:
      D.7456 = m->mflags;
      D.7457 = D.7456 & 2;
      if (D.7457 != 0) goto <D.7451>; else goto <D.7452>;
      <D.7451>:
      D.7458 = &m->mutex;
      D.7459 = pthread_mutex_lock (D.7458);
      if (D.7459 != 0) goto <D.7460>; else goto <D.7461>;
      <D.7460>:
      D.7428 = 0B;
      return D.7428;
      <D.7461>:
      <D.7452>:
      mem.52 = (long unsigned int) mem;
      D.7463 = mem.52 % alignment;
      if (D.7463 != 0) goto <D.7464>; else goto <D.7465>;
      <D.7464>:
      {
        char * br;
        char * pos;
        struct malloc_chunk * newp;
        size_t leadsize;
        size_t newsize;

        D.7466 = alignment + 18446744073709551615;
        D.7467 = mem + D.7466;
        D.7468 = (long unsigned int) D.7467;
        D.7469 = -alignment;
        D.7470 = D.7468 & D.7469;
        D.7471 = D.7470 + 18446744073709551600;
        br = (char *) D.7471;
        br.54 = (long int) br;
        p.55 = (long int) p;
        D.7475 = br.54 - p.55;
        D.7476 = (long unsigned int) D.7475;
        if (D.7476 <= 31) goto <D.7477>; else goto <D.7478>;
        <D.7477>:
        iftmp.53 = br + alignment;
        goto <D.7479>;
        <D.7478>:
        iftmp.53 = br;
        <D.7479>:
        pos = iftmp.53;
        newp = pos;
        pos.56 = (long int) pos;
        p.55 = (long int) p;
        D.7481 = pos.56 - p.55;
        leadsize = (size_t) D.7481;
        D.7482 = p->head;
        D.7483 = D.7482 & 18446744073709551612;
        newsize = D.7483 - leadsize;
        D.7482 = p->head;
        D.7486 = D.7482 & 1;
        if (D.7486 == 0) goto <D.7487>; else goto <D.7484>;
        <D.7487>:
        D.7488 = p->prev_foot;
        D.7489 = D.7488 & 1;
        if (D.7489 != 0) goto <D.7490>; else goto <D.7484>;
        <D.7490>:
        D.7488 = p->prev_foot;
        D.7491 = D.7488 + leadsize;
        newp->prev_foot = D.7491;
        D.7492 = newsize | 2;
        newp->head = D.7492;
        goto <D.7485>;
        <D.7484>:
        D.7493 = newp->head;
        D.7494 = D.7493 & 1;
        D.7495 = D.7494 | newsize;
        D.7496 = D.7495 | 2;
        newp->head = D.7496;
        D.7497 = newp + newsize;
        D.7497 = newp + newsize;
        D.7498 = D.7497->head;
        D.7499 = D.7498 | 1;
        D.7497->head = D.7499;
        D.7482 = p->head;
        D.7486 = D.7482 & 1;
        D.7500 = D.7486 | leadsize;
        D.7501 = D.7500 | 2;
        p->head = D.7501;
        D.7502 = p + leadsize;
        D.7502 = p + leadsize;
        D.7503 = D.7502->head;
        D.7504 = D.7503 | 1;
        D.7502->head = D.7504;
        leader = p + 16;
        <D.7485>:
        p = newp;
      }
      <D.7465>:
      D.7482 = p->head;
      D.7486 = D.7482 & 1;
      if (D.7486 != 0) goto <D.7505>; else goto <D.7507>;
      <D.7507>:
      D.7488 = p->prev_foot;
      D.7489 = D.7488 & 1;
      if (D.7489 == 0) goto <D.7505>; else goto <D.7506>;
      <D.7505>:
      {
        size_t size;

        D.7482 = p->head;
        size = D.7482 & 18446744073709551612;
        D.7508 = nb + 32;
        if (D.7508 < size) goto <D.7509>; else goto <D.7510>;
        <D.7509>:
        {
          size_t remainder_size;
          struct malloc_chunk * remainder;

          remainder_size = size - nb;
          remainder = p + nb;
          D.7482 = p->head;
          D.7486 = D.7482 & 1;
          D.7511 = D.7486 | nb;
          D.7512 = D.7511 | 2;
          p->head = D.7512;
          D.7513 = p + nb;
          D.7513 = p + nb;
          D.7514 = D.7513->head;
          D.7515 = D.7514 | 1;
          D.7513->head = D.7515;
          D.7516 = remainder->head;
          D.7517 = D.7516 & 1;
          D.7518 = D.7517 | remainder_size;
          D.7519 = D.7518 | 2;
          remainder->head = D.7519;
          D.7520 = remainder + remainder_size;
          D.7520 = remainder + remainder_size;
          D.7521 = D.7520->head;
          D.7522 = D.7521 | 1;
          D.7520->head = D.7522;
          trailer = remainder + 16;
        }
        <D.7510>:
      }
      <D.7506>:
      D.7456 = m->mflags;
      D.7457 = D.7456 & 2;
      if (D.7457 != 0) goto <D.7523>; else goto <D.7524>;
      <D.7523>:
      D.7458 = &m->mutex;
      pthread_mutex_unlock (D.7458);
      <D.7524>:
      if (leader != 0B) goto <D.7525>; else goto <D.7526>;
      <D.7525>:
      dlfree (leader);
      <D.7526>:
      if (trailer != 0B) goto <D.7527>; else goto <D.7528>;
      <D.7527>:
      dlfree (trailer);
      <D.7528>:
      D.7428 = p + 16;
      return D.7428;
    }
    <D.7449>:
  }
  <D.7441>:
  D.7428 = 0B;
  return D.7428;
}