dlmalloc (size_t bytes)
{
  long unsigned int D.5596;
  int D.5598;
  unsigned int D.5599;
  unsigned int D.5600;
  int D.5601;
  long unsigned int iftmp.0;
  long unsigned int D.5607;
  long unsigned int D.5609;
  unsigned int D.5610;
  int idx.1;
  unsigned int D.5612;
  unsigned int D.5615;
  _Bool D.5616;
  unsigned int D.5617;
  unsigned int D.5618;
  unsigned int D.5621;
  unsigned int D.5622;
  unsigned int D.5623;
  char * D.5625;
  _Bool D.5626;
  long int D.5627;
  long int D.5628;
  unsigned int D.5632;
  unsigned int D.5633;
  long unsigned int D.5634;
  sizetype D.5635;
  struct malloc_chunk * D.5636;
  long unsigned int D.5637;
  long unsigned int D.5638;
  long unsigned int D.5639;
  unsigned int D.5644;
  unsigned int D.5645;
  unsigned int D.5646;
  unsigned int D.5647;
  unsigned int D.5648;
  unsigned int D.5649;
  int K.2;
  unsigned int D.5651;
  unsigned int K.3;
  unsigned int D.5653;
  unsigned int K.4;
  unsigned int D.5655;
  unsigned int K.5;
  unsigned int K.6;
  unsigned int D.5658;
  int i.7;
  unsigned int D.5662;
  unsigned int D.5663;
  unsigned int D.5664;
  _Bool D.5666;
  long int D.5667;
  long int D.5668;
  unsigned int D.5672;
  long unsigned int D.5673;
  unsigned int D.5676;
  long unsigned int D.5677;
  sizetype D.5678;
  struct malloc_chunk * D.5679;
  long unsigned int D.5680;
  long unsigned int D.5681;
  long unsigned int D.5683;
  long unsigned int D.5684;
  struct malloc_chunk * D.5685;
  long unsigned int D.5688;
  unsigned int D.5689;
  int I.8;
  unsigned int D.5691;
  unsigned int D.5692;
  unsigned int D.5695;
  struct malloc_chunk * D.5697;
  _Bool D.5698;
  long int D.5699;
  long int D.5700;
  unsigned int D.5704;
  struct malloc_chunk * D.5719;
  long unsigned int D.5720;
  struct malloc_chunk * D.5721;
  long unsigned int D.5723;
  struct malloc_chunk * D.5724;
  long unsigned int D.5725;
  long unsigned int D.5726;
  long unsigned int D.5727;
  long unsigned int D.5730;
  struct malloc_chunk * D.5731;
  long unsigned int D.5732;
  void * D.5735;
  void postaction = <<< error >>>;

  D.5596 = mparams.page_size;
  if (D.5596 != 0) goto <D.5592>; else goto <D.5597>;
  <D.5597>:
  D.5598 = init_mparams ();
  if (D.5598 == 0) goto <D.5592>; else goto <D.5593>;
  <D.5592>:
  D.5599 = _gm_.mflags;
  D.5600 = D.5599 & 2;
  if (D.5600 == 0) goto <D.5594>; else goto <D.5593>;
  <D.5593>:
  D.5601 = pthread_mutex_lock (&_gm_.mutex);
  if (D.5601 == 0) goto <D.5594>; else goto <D.5595>;
  <D.5594>:
  {
    void * mem;
    size_t nb;

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

      if (bytes > 22) goto <D.5605>; else goto <D.5606>;
      <D.5605>:
      D.5607 = bytes + 15;
      iftmp.0 = D.5607 & 18446744073709551608;
      goto <D.5608>;
      <D.5606>:
      iftmp.0 = 32;
      <D.5608>:
      nb = iftmp.0;
      D.5609 = nb >> 3;
      idx = (bindex_t) D.5609;
      D.5610 = _gm_.smallmap;
      idx.1 = (int) idx;
      smallbits = D.5610 >> idx.1;
      D.5612 = smallbits & 3;
      if (D.5612 != 0) goto <D.5613>; else goto <D.5614>;
      <D.5613>:
      {
        struct malloc_chunk * b;
        struct malloc_chunk * p;

        D.5615 = smallbits & 1;
        D.5616 = D.5615 == 0;
        D.5617 = (unsigned int) D.5616;
        idx = D.5617 + idx;
        D.5618 = idx << 1;
        b = &_gm_.smallbins[D.5618];
        p = b->fd;
        {
          struct malloc_chunk * F;

          F = p->fd;
          if (b == F) goto <D.5619>; else goto <D.5620>;
          <D.5619>:
          D.5610 = _gm_.smallmap;
          idx.1 = (int) idx;
          D.5621 = 1 << idx.1;
          D.5622 = ~D.5621;
          D.5623 = D.5610 & D.5622;
          _gm_.smallmap = D.5623;
          goto <D.5624>;
          <D.5620>:
          D.5625 = _gm_.least_addr;
          D.5626 = D.5625 <= F;
          D.5627 = (long int) D.5626;
          D.5628 = __builtin_expect (D.5627, 1);
          if (D.5628 != 0) goto <D.5629>; else goto <D.5630>;
          <D.5629>:
          b->fd = F;
          F->bk = b;
          goto <D.5631>;
          <D.5630>:
          abort ();
          <D.5631>:
          <D.5624>:
        }
        D.5632 = idx << 3;
        D.5633 = D.5632 | 3;
        D.5634 = (long unsigned int) D.5633;
        p->head = D.5634;
        D.5632 = idx << 3;
        D.5635 = (sizetype) D.5632;
        D.5636 = p + D.5635;
        D.5632 = idx << 3;
        D.5635 = (sizetype) D.5632;
        D.5636 = p + D.5635;
        D.5637 = D.5636->head;
        D.5638 = D.5637 | 1;
        D.5636->head = D.5638;
        mem = p + 16;
        goto postaction;
      }
      <D.5614>:
      D.5639 = _gm_.dvsize;
      if (D.5639 < nb) goto <D.5640>; else goto <D.5641>;
      <D.5640>:
      if (smallbits != 0) goto <D.5642>; else goto <D.5643>;
      <D.5642>:
      {
        struct malloc_chunk * b;
        struct malloc_chunk * p;
        struct malloc_chunk * r;
        size_t rsize;
        bindex_t i;
        binmap_t leftbits;
        binmap_t leastbit;

        idx.1 = (int) idx;
        D.5644 = smallbits << idx.1;
        idx.1 = (int) idx;
        D.5621 = 1 << idx.1;
        D.5645 = D.5621 << 1;
        idx.1 = (int) idx;
        D.5621 = 1 << idx.1;
        D.5645 = D.5621 << 1;
        D.5646 = -D.5645;
        D.5647 = D.5645 | D.5646;
        leftbits = D.5644 & D.5647;
        D.5648 = -leftbits;
        leastbit = D.5648 & leftbits;
        {
          unsigned int Y;
          unsigned int K;
          unsigned int N;

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

          F = p->fd;
          if (b == F) goto <D.5659>; else goto <D.5660>;
          <D.5659>:
          D.5610 = _gm_.smallmap;
          i.7 = (int) i;
          D.5662 = 1 << i.7;
          D.5663 = ~D.5662;
          D.5664 = D.5610 & D.5663;
          _gm_.smallmap = D.5664;
          goto <D.5665>;
          <D.5660>:
          D.5625 = _gm_.least_addr;
          D.5666 = D.5625 <= F;
          D.5667 = (long int) D.5666;
          D.5668 = __builtin_expect (D.5667, 1);
          if (D.5668 != 0) goto <D.5669>; else goto <D.5670>;
          <D.5669>:
          b->fd = F;
          F->bk = b;
          goto <D.5671>;
          <D.5670>:
          abort ();
          <D.5671>:
          <D.5665>:
        }
        D.5672 = i << 3;
        D.5673 = (long unsigned int) D.5672;
        rsize = D.5673 - nb;
        if (rsize <= 31) goto <D.5674>; else goto <D.5675>;
        <D.5674>:
        D.5672 = i << 3;
        D.5676 = D.5672 | 3;
        D.5677 = (long unsigned int) D.5676;
        p->head = D.5677;
        D.5672 = i << 3;
        D.5678 = (sizetype) D.5672;
        D.5679 = p + D.5678;
        D.5672 = i << 3;
        D.5678 = (sizetype) D.5672;
        D.5679 = p + D.5678;
        D.5680 = D.5679->head;
        D.5681 = D.5680 | 1;
        D.5679->head = D.5681;
        goto <D.5682>;
        <D.5675>:
        D.5683 = nb | 3;
        p->head = D.5683;
        r = p + nb;
        D.5684 = rsize | 1;
        r->head = D.5684;
        D.5685 = r + rsize;
        D.5685->prev_foot = rsize;
        {
          size_t DVS;

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

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

              D.5688 = DVS >> 3;
              I = (bindex_t) D.5688;
              D.5689 = I << 1;
              B = &_gm_.smallbins[D.5689];
              F = B;
              D.5610 = _gm_.smallmap;
              I.8 = (int) I;
              D.5691 = 1 << I.8;
              D.5692 = D.5610 & D.5691;
              if (D.5692 == 0) goto <D.5693>; else goto <D.5694>;
              <D.5693>:
              D.5610 = _gm_.smallmap;
              I.8 = (int) I;
              D.5691 = 1 << I.8;
              D.5695 = D.5610 | D.5691;
              _gm_.smallmap = D.5695;
              goto <D.5696>;
              <D.5694>:
              D.5697 = B->fd;
              D.5625 = _gm_.least_addr;
              D.5698 = D.5697 >= D.5625;
              D.5699 = (long int) D.5698;
              D.5700 = __builtin_expect (D.5699, 1);
              if (D.5700 != 0) goto <D.5701>; else goto <D.5702>;
              <D.5701>:
              F = B->fd;
              goto <D.5703>;
              <D.5702>:
              abort ();
              <D.5703>:
              <D.5696>:
              B->fd = DV;
              F->bk = DV;
              DV->fd = F;
              DV->bk = B;
            }
          }
          <D.5687>:
          _gm_.dvsize = rsize;
          _gm_.dv = r;
        }
        <D.5682>:
        mem = p + 16;
        goto postaction;
      }
      <D.5643>:
      D.5704 = _gm_.treemap;
      if (D.5704 != 0) goto <D.5705>; else goto <D.5706>;
      <D.5705>:
      mem = tmalloc_small (&_gm_, nb);
      if (mem != 0B) goto postaction; else goto <D.5707>;
      <D.5707>:
      <D.5706>:
      <D.5641>:
    }
    goto <D.5708>;
    <D.5603>:
    if (bytes > 18446744073709551487) goto <D.5709>; else goto <D.5710>;
    <D.5709>:
    nb = 18446744073709551615;
    goto <D.5711>;
    <D.5710>:
    D.5607 = bytes + 15;
    nb = D.5607 & 18446744073709551608;
    D.5704 = _gm_.treemap;
    if (D.5704 != 0) goto <D.5712>; else goto <D.5713>;
    <D.5712>:
    mem = tmalloc_large (&_gm_, nb);
    if (mem != 0B) goto postaction; else goto <D.5714>;
    <D.5714>:
    <D.5713>:
    <D.5711>:
    <D.5708>:
    D.5639 = _gm_.dvsize;
    if (D.5639 >= nb) goto <D.5715>; else goto <D.5716>;
    <D.5715>:
    {
      size_t rsize;
      struct malloc_chunk * p;

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

        D.5719 = p + nb;
        _gm_.dv = D.5719;
        r = _gm_.dv;
        _gm_.dvsize = rsize;
        D.5720 = rsize | 1;
        r->head = D.5720;
        D.5721 = r + rsize;
        D.5721->prev_foot = rsize;
        D.5683 = nb | 3;
        p->head = D.5683;
      }
      goto <D.5722>;
      <D.5718>:
      {
        size_t dvs;

        dvs = _gm_.dvsize;
        _gm_.dvsize = 0;
        _gm_.dv = 0B;
        D.5723 = dvs | 3;
        p->head = D.5723;
        D.5724 = p + dvs;
        D.5724 = p + dvs;
        D.5725 = D.5724->head;
        D.5726 = D.5725 | 1;
        D.5724->head = D.5726;
      }
      <D.5722>:
      mem = p + 16;
      goto postaction;
    }
    <D.5716>:
    D.5727 = _gm_.topsize;
    if (D.5727 > nb) goto <D.5728>; else goto <D.5729>;
    <D.5728>:
    {
      size_t rsize;
      struct malloc_chunk * p;
      struct malloc_chunk * r;

      D.5727 = _gm_.topsize;
      D.5730 = D.5727 - nb;
      _gm_.topsize = D.5730;
      rsize = _gm_.topsize;
      p = _gm_.top;
      D.5731 = p + nb;
      _gm_.top = D.5731;
      r = _gm_.top;
      D.5732 = rsize | 1;
      r->head = D.5732;
      D.5683 = nb | 3;
      p->head = D.5683;
      mem = p + 16;
      goto postaction;
    }
    <D.5729>:
    mem = sys_alloc (&_gm_, nb);
    postaction:
    D.5599 = _gm_.mflags;
    D.5600 = D.5599 & 2;
    if (D.5600 != 0) goto <D.5733>; else goto <D.5734>;
    <D.5733>:
    pthread_mutex_unlock (&_gm_.mutex);
    <D.5734>:
    D.5735 = mem;
    return D.5735;
  }
  <D.5595>:
  D.5735 = 0B;
  return D.5735;
}


init_mparams ()
{
  long unsigned int D.5737;
  long unsigned int D.5740;
  unsigned int D.5743;
  long unsigned int D.5746;
  long unsigned int D.5747;
  long unsigned int D.5748;
  long unsigned int D.5750;
  long unsigned int D.5751;
  int D.5752;

  D.5737 = mparams.page_size;
  if (D.5737 == 0) goto <D.5738>; else goto <D.5739>;
  <D.5738>:
  {
    size_t s;

    mparams.mmap_threshold = 262144;
    mparams.trim_threshold = 2097152;
    mparams.default_mflags = 7;
    s = 1482184792;
    pthread_mutex_lock (&magic_init_mutex);
    D.5740 = mparams.magic;
    if (D.5740 == 0) goto <D.5741>; else goto <D.5742>;
    <D.5741>:
    mparams.magic = s;
    pthread_mutex_init (&_gm_.mutex, 0B);
    D.5743 = mparams.default_mflags;
    _gm_.mflags = D.5743;
    <D.5742>:
    pthread_mutex_unlock (&magic_init_mutex);
    mparams.page_size = 4096;
    mparams.granularity = 65536;
    D.5746 = mparams.granularity;
    D.5746 = mparams.granularity;
    D.5747 = D.5746 + 18446744073709551615;
    D.5748 = D.5746 & D.5747;
    if (D.5748 != 0) goto <D.5744>; else goto <D.5749>;
    <D.5749>:
    D.5737 = mparams.page_size;
    D.5737 = mparams.page_size;
    D.5750 = D.5737 + 18446744073709551615;
    D.5751 = D.5737 & D.5750;
    if (D.5751 != 0) goto <D.5744>; else goto <D.5745>;
    <D.5744>:
    abort ();
    <D.5745>:
  }
  <D.5739>:
  D.5752 = 0;
  return D.5752;
}


tmalloc_small (struct malloc_state * m, size_t nb)
{
  unsigned int D.5754;
  unsigned int D.5755;
  unsigned int D.5756;
  int K.9;
  unsigned int D.5758;
  unsigned int K.10;
  unsigned int D.5760;
  unsigned int K.11;
  unsigned int D.5762;
  unsigned int K.12;
  unsigned int K.13;
  long unsigned int D.5765;
  long unsigned int D.5766;
  struct malloc_tree_chunk * iftmp.14;
  struct malloc_tree_chunk * D.5770;
  char * D.5774;
  _Bool D.5775;
  long int D.5776;
  long int D.5777;
  _Bool D.5780;
  long int D.5781;
  long int D.5782;
  struct malloc_tree_chunk * D.5785;
  _Bool D.5788;
  long int D.5789;
  long int D.5790;
  struct malloc_tree_chunk * D.5798;
  _Bool D.5800;
  long int D.5801;
  long int D.5802;
  unsigned int D.5808;
  struct malloc_tree_chunk * D.5809;
  int D.5814;
  unsigned int D.5815;
  unsigned int D.5816;
  unsigned int D.5817;
  _Bool D.5819;
  long int D.5820;
  long int D.5821;
  struct malloc_tree_chunk * D.5824;
  _Bool D.5831;
  long int D.5832;
  long int D.5833;
  _Bool D.5838;
  long int D.5839;
  long int D.5840;
  _Bool D.5846;
  long int D.5847;
  long int D.5848;
  long unsigned int D.5855;
  long unsigned int D.5856;
  struct malloc_chunk * D.5857;
  long unsigned int D.5858;
  long unsigned int D.5859;
  long unsigned int D.5861;
  long unsigned int D.5862;
  struct malloc_chunk * D.5863;
  long unsigned int D.5866;
  unsigned int D.5867;
  unsigned int D.5868;
  int I.15;
  unsigned int D.5870;
  unsigned int D.5871;
  unsigned int D.5874;
  struct malloc_chunk * D.5876;
  _Bool D.5877;
  long int D.5878;
  long int D.5879;
  void * D.5883;
  struct malloc_tree_chunk * t;
  struct malloc_tree_chunk * v;
  size_t rsize;
  bindex_t i;
  binmap_t leastbit;

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

    Y = leastbit + 4294967295;
    D.5756 = Y >> 12;
    K = D.5756 & 16;
    N = K;
    K.9 = (int) K;
    Y = Y >> K.9;
    D.5758 = Y >> 5;
    K = D.5758 & 8;
    K.10 = K;
    N = K.10 + N;
    K.9 = (int) K;
    Y = Y >> K.9;
    D.5760 = Y >> 2;
    K = D.5760 & 4;
    K.11 = K;
    N = K.11 + N;
    K.9 = (int) K;
    Y = Y >> K.9;
    D.5762 = Y >> 1;
    K = D.5762 & 2;
    K.12 = K;
    N = K.12 + N;
    K.9 = (int) K;
    Y = Y >> K.9;
    D.5762 = Y >> 1;
    K = D.5762 & 1;
    K.13 = K;
    N = K.13 + N;
    K.9 = (int) K;
    Y = Y >> K.9;
    i = N + Y;
  }
  t = m->treebins[i];
  v = t;
  D.5765 = t->head;
  D.5766 = D.5765 & 18446744073709551612;
  rsize = D.5766 - nb;
  goto <D.5452>;
  <D.5451>:
  {
    size_t trem;

    D.5765 = t->head;
    D.5766 = D.5765 & 18446744073709551612;
    trem = D.5766 - nb;
    if (trem < rsize) goto <D.5767>; else goto <D.5768>;
    <D.5767>:
    rsize = trem;
    v = t;
    <D.5768>:
  }
  <D.5452>:
  D.5770 = t->child[0];
  if (D.5770 != 0B) goto <D.5771>; else goto <D.5772>;
  <D.5771>:
  iftmp.14 = t->child[0];
  goto <D.5773>;
  <D.5772>:
  iftmp.14 = t->child[1];
  <D.5773>:
  t = iftmp.14;
  if (t != 0B) goto <D.5451>; else goto <D.5453>;
  <D.5453>:
  D.5774 = m->least_addr;
  D.5775 = D.5774 <= v;
  D.5776 = (long int) D.5775;
  D.5777 = __builtin_expect (D.5776, 1);
  if (D.5777 != 0) goto <D.5778>; else goto <D.5779>;
  <D.5778>:
  {
    struct malloc_chunk * r;

    r = v + nb;
    D.5780 = v < r;
    D.5781 = (long int) D.5780;
    D.5782 = __builtin_expect (D.5781, 1);
    if (D.5782 != 0) goto <D.5783>; else goto <D.5784>;
    <D.5783>:
    {
      struct malloc_tree_chunk * XP;
      struct malloc_tree_chunk * R;

      XP = v->parent;
      D.5785 = v->bk;
      if (D.5785 != v) goto <D.5786>; else goto <D.5787>;
      <D.5786>:
      {
        struct malloc_tree_chunk * F;

        F = v->fd;
        R = v->bk;
        D.5774 = m->least_addr;
        D.5788 = D.5774 <= F;
        D.5789 = (long int) D.5788;
        D.5790 = __builtin_expect (D.5789, 1);
        if (D.5790 != 0) goto <D.5791>; else goto <D.5792>;
        <D.5791>:
        F->bk = R;
        R->fd = F;
        goto <D.5793>;
        <D.5792>:
        abort ();
        <D.5793>:
      }
      goto <D.5794>;
      <D.5787>:
      {
        struct malloc_tree_chunk * * RP;

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

          goto <D.5461>;
          <D.5460>:
          RP = CP;
          R = *RP;
          <D.5461>:
          CP = &R->child[1];
          D.5798 = *CP;
          if (D.5798 != 0B) goto <D.5460>; else goto <D.5799>;
          <D.5799>:
          CP = &R->child[0];
          D.5798 = *CP;
          if (D.5798 != 0B) goto <D.5460>; else goto <D.5462>;
          <D.5462>:
          D.5774 = m->least_addr;
          D.5800 = D.5774 <= RP;
          D.5801 = (long int) D.5800;
          D.5802 = __builtin_expect (D.5801, 1);
          if (D.5802 != 0) goto <D.5803>; else goto <D.5804>;
          <D.5803>:
          *RP = 0B;
          goto <D.5805>;
          <D.5804>:
          abort ();
          <D.5805>:
        }
        <D.5796>:
      }
      <D.5794>:
      if (XP != 0B) goto <D.5806>; else goto <D.5807>;
      <D.5806>:
      {
        struct malloc_tree_chunk * * H;

        D.5808 = v->index;
        H = &m->treebins[D.5808];
        D.5809 = *H;
        if (D.5809 == v) goto <D.5810>; else goto <D.5811>;
        <D.5810>:
        *H = R;
        D.5809 = *H;
        if (D.5809 == 0B) goto <D.5812>; else goto <D.5813>;
        <D.5812>:
        D.5754 = m->treemap;
        D.5808 = v->index;
        D.5814 = (int) D.5808;
        D.5815 = 1 << D.5814;
        D.5816 = ~D.5815;
        D.5817 = D.5754 & D.5816;
        m->treemap = D.5817;
        <D.5813>:
        goto <D.5818>;
        <D.5811>:
        D.5774 = m->least_addr;
        D.5819 = D.5774 <= XP;
        D.5820 = (long int) D.5819;
        D.5821 = __builtin_expect (D.5820, 1);
        if (D.5821 != 0) goto <D.5822>; else goto <D.5823>;
        <D.5822>:
        D.5824 = XP->child[0];
        if (D.5824 == v) goto <D.5825>; else goto <D.5826>;
        <D.5825>:
        XP->child[0] = R;
        goto <D.5827>;
        <D.5826>:
        XP->child[1] = R;
        <D.5827>:
        goto <D.5828>;
        <D.5823>:
        abort ();
        <D.5828>:
        <D.5818>:
        if (R != 0B) goto <D.5829>; else goto <D.5830>;
        <D.5829>:
        D.5774 = m->least_addr;
        D.5831 = D.5774 <= R;
        D.5832 = (long int) D.5831;
        D.5833 = __builtin_expect (D.5832, 1);
        if (D.5833 != 0) goto <D.5834>; else goto <D.5835>;
        <D.5834>:
        {
          struct malloc_tree_chunk * C0;
          struct malloc_tree_chunk * C1;

          R->parent = XP;
          C0 = v->child[0];
          if (C0 != 0B) goto <D.5836>; else goto <D.5837>;
          <D.5836>:
          D.5774 = m->least_addr;
          D.5838 = D.5774 <= C0;
          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>:
          R->child[0] = C0;
          C0->parent = R;
          goto <D.5843>;
          <D.5842>:
          abort ();
          <D.5843>:
          <D.5837>:
          C1 = v->child[1];
          if (C1 != 0B) goto <D.5844>; else goto <D.5845>;
          <D.5844>:
          D.5774 = m->least_addr;
          D.5846 = D.5774 <= C1;
          D.5847 = (long int) D.5846;
          D.5848 = __builtin_expect (D.5847, 1);
          if (D.5848 != 0) goto <D.5849>; else goto <D.5850>;
          <D.5849>:
          R->child[1] = C1;
          C1->parent = R;
          goto <D.5851>;
          <D.5850>:
          abort ();
          <D.5851>:
          <D.5845>:
        }
        goto <D.5852>;
        <D.5835>:
        abort ();
        <D.5852>:
        <D.5830>:
      }
      <D.5807>:
    }
    if (rsize <= 31) goto <D.5853>; else goto <D.5854>;
    <D.5853>:
    D.5855 = rsize + nb;
    D.5856 = D.5855 | 3;
    v->head = D.5856;
    D.5855 = rsize + nb;
    D.5857 = v + D.5855;
    D.5855 = rsize + nb;
    D.5857 = v + D.5855;
    D.5858 = D.5857->head;
    D.5859 = D.5858 | 1;
    D.5857->head = D.5859;
    goto <D.5860>;
    <D.5854>:
    D.5861 = nb | 3;
    v->head = D.5861;
    D.5862 = rsize | 1;
    r->head = D.5862;
    D.5863 = r + rsize;
    D.5863->prev_foot = rsize;
    {
      size_t DVS;

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

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

          D.5866 = DVS >> 3;
          I = (bindex_t) D.5866;
          D.5867 = I << 1;
          B = &m->smallbins[D.5867];
          F = B;
          D.5868 = m->smallmap;
          I.15 = (int) I;
          D.5870 = 1 << I.15;
          D.5871 = D.5868 & D.5870;
          if (D.5871 == 0) goto <D.5872>; else goto <D.5873>;
          <D.5872>:
          D.5868 = m->smallmap;
          I.15 = (int) I;
          D.5870 = 1 << I.15;
          D.5874 = D.5868 | D.5870;
          m->smallmap = D.5874;
          goto <D.5875>;
          <D.5873>:
          D.5876 = B->fd;
          D.5774 = m->least_addr;
          D.5877 = D.5876 >= D.5774;
          D.5878 = (long int) D.5877;
          D.5879 = __builtin_expect (D.5878, 1);
          if (D.5879 != 0) goto <D.5880>; else goto <D.5881>;
          <D.5880>:
          F = B->fd;
          goto <D.5882>;
          <D.5881>:
          abort ();
          <D.5882>:
          <D.5875>:
          B->fd = DV;
          F->bk = DV;
          DV->fd = F;
          DV->bk = B;
        }
      }
      <D.5865>:
      m->dvsize = rsize;
      m->dv = r;
    }
    <D.5860>:
    D.5883 = v + 16;
    return D.5883;
    <D.5784>:
  }
  <D.5779>:
  abort ();
  D.5883 = 0B;
  return D.5883;
}


tmalloc_large (struct malloc_state * m, size_t nb)
{
  unsigned int D.5891;
  unsigned int D.5892;
  int N.16;
  unsigned int D.5894;
  unsigned int D.5895;
  int K.17;
  unsigned int D.5897;
  unsigned int D.5898;
  unsigned int K.18;
  unsigned int D.5900;
  unsigned int D.5901;
  unsigned int D.5902;
  unsigned int D.5903;
  int D.5904;
  long unsigned int D.5905;
  unsigned int D.5906;
  unsigned int D.5907;
  int iftmp.19;
  unsigned int D.5913;
  unsigned int D.5914;
  long unsigned int D.5915;
  long unsigned int D.5916;
  long unsigned int D.5918;
  long unsigned int D.5919;
  long unsigned int D.5923;
  _Bool D.5924;
  _Bool D.5925;
  _Bool D.5926;
  _Bool D.5931;
  _Bool D.5932;
  _Bool D.5933;
  int idx.20;
  unsigned int D.5937;
  unsigned int D.5938;
  unsigned int D.5939;
  unsigned int D.5940;
  unsigned int D.5941;
  unsigned int D.5944;
  unsigned int D.5945;
  int K.21;
  unsigned int D.5947;
  unsigned int K.22;
  unsigned int D.5949;
  unsigned int K.23;
  unsigned int D.5951;
  unsigned int K.24;
  unsigned int K.25;
  struct malloc_tree_chunk * iftmp.26;
  struct malloc_tree_chunk * D.5957;
  long unsigned int D.5963;
  long unsigned int D.5964;
  char * D.5967;
  _Bool D.5968;
  long int D.5969;
  long int D.5970;
  _Bool D.5973;
  long int D.5974;
  long int D.5975;
  struct malloc_tree_chunk * D.5978;
  _Bool D.5981;
  long int D.5982;
  long int D.5983;
  struct malloc_tree_chunk * D.5991;
  _Bool D.5993;
  long int D.5994;
  long int D.5995;
  unsigned int D.6001;
  struct malloc_tree_chunk * D.6002;
  int D.6007;
  unsigned int D.6008;
  unsigned int D.6009;
  unsigned int D.6010;
  _Bool D.6012;
  long int D.6013;
  long int D.6014;
  struct malloc_tree_chunk * D.6017;
  _Bool D.6024;
  long int D.6025;
  long int D.6026;
  _Bool D.6031;
  long int D.6032;
  long int D.6033;
  _Bool D.6039;
  long int D.6040;
  long int D.6041;
  long unsigned int D.6048;
  long unsigned int D.6049;
  struct malloc_chunk * D.6050;
  long unsigned int D.6051;
  long unsigned int D.6052;
  long unsigned int D.6054;
  long unsigned int D.6055;
  struct malloc_chunk * D.6056;
  long unsigned int D.6057;
  unsigned int D.6060;
  unsigned int D.6061;
  int I.27;
  unsigned int D.6063;
  unsigned int D.6064;
  unsigned int D.6067;
  struct malloc_chunk * D.6069;
  _Bool D.6070;
  long int D.6071;
  long int D.6072;
  unsigned int D.6083;
  unsigned int D.6084;
  int N.28;
  unsigned int D.6086;
  unsigned int D.6087;
  int K.29;
  unsigned int D.6089;
  unsigned int D.6090;
  unsigned int K.30;
  unsigned int D.6092;
  unsigned int D.6093;
  unsigned int D.6094;
  unsigned int D.6095;
  int D.6096;
  long unsigned int D.6097;
  unsigned int D.6098;
  unsigned int D.6099;
  struct malloc_tree_chunk * D.6100;
  int I.31;
  unsigned int D.6102;
  unsigned int D.6103;
  unsigned int D.6106;
  struct malloc_tree_chunk * D.6107;
  int iftmp.32;
  unsigned int D.6112;
  unsigned int D.6113;
  long unsigned int D.6114;
  long unsigned int D.6115;
  long unsigned int D.6117;
  long unsigned int D.6118;
  long unsigned int D.6121;
  struct malloc_tree_chunk * D.6122;
  _Bool D.6126;
  long int D.6127;
  long int D.6128;
  _Bool D.6133;
  long int D.6134;
  long int D.6135;
  _Bool D.6137;
  long int D.6138;
  long int D.6139;
  struct malloc_tree_chunk * D.6141;
  void * D.6142;
  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.5885>; else goto <D.5886>;
    <D.5885>:
    idx = 0;
    goto <D.5887>;
    <D.5886>:
    if (X > 65535) goto <D.5888>; else goto <D.5889>;
    <D.5888>:
    idx = 31;
    goto <D.5890>;
    <D.5889>:
    {
      unsigned int Y;
      unsigned int N;
      unsigned int K;

      Y = (unsigned int) X;
      D.5891 = Y + 4294967040;
      D.5892 = D.5891 >> 16;
      N = D.5892 & 8;
      N.16 = (int) N;
      Y = Y << N.16;
      D.5894 = Y + 4294963200;
      D.5895 = D.5894 >> 16;
      K = D.5895 & 4;
      N = N + K;
      K.17 = (int) K;
      Y = Y << K.17;
      D.5897 = Y + 4294950912;
      D.5898 = D.5897 >> 16;
      K = D.5898 & 2;
      K.18 = K;
      N = K.18 + N;
      K.17 = (int) K;
      Y = Y << K.17;
      D.5900 = Y >> 15;
      D.5901 = D.5900 - N;
      K = D.5901 + 14;
      D.5902 = K << 1;
      D.5903 = K + 7;
      D.5904 = (int) D.5903;
      D.5905 = nb >> D.5904;
      D.5906 = (unsigned int) D.5905;
      D.5907 = D.5906 & 1;
      idx = D.5902 + D.5907;
    }
    <D.5890>:
    <D.5887>:
  }
  t = m->treebins[idx];
  if (t != 0B) goto <D.5908>; else goto <D.5909>;
  <D.5908>:
  {
    size_t sizebits;
    struct malloc_tree_chunk * rst;

    if (idx != 31) goto <D.5911>; else goto <D.5912>;
    <D.5911>:
    D.5913 = idx >> 1;
    D.5914 = D.5913 + 6;
    D.5915 = (long unsigned int) D.5914;
    D.5916 = 63 - D.5915;
    iftmp.19 = (int) D.5916;
    goto <D.5917>;
    <D.5912>:
    iftmp.19 = 0;
    <D.5917>:
    sizebits = nb << iftmp.19;
    rst = 0B;
    <D.5399>:
    {
      struct malloc_tree_chunk * rt;
      size_t trem;

      D.5918 = t->head;
      D.5919 = D.5918 & 18446744073709551612;
      trem = D.5919 - nb;
      if (trem < rsize) goto <D.5920>; else goto <D.5921>;
      <D.5920>:
      v = t;
      rsize = trem;
      if (rsize == 0) goto <D.5398>; else goto <D.5922>;
      <D.5922>:
      <D.5921>:
      rt = t->child[1];
      D.5923 = sizebits >> 63;
      t = t->child[D.5923];
      D.5924 = rt != 0B;
      D.5925 = rt != t;
      D.5926 = D.5924 & D.5925;
      if (D.5926 != 0) goto <D.5927>; else goto <D.5928>;
      <D.5927>:
      rst = rt;
      <D.5928>:
      if (t == 0B) goto <D.5929>; else goto <D.5930>;
      <D.5929>:
      t = rst;
      goto <D.5398>;
      <D.5930>:
      sizebits = sizebits << 1;
    }
    goto <D.5399>;
    <D.5398>:
  }
  <D.5909>:
  D.5931 = t == 0B;
  D.5932 = v == 0B;
  D.5933 = D.5931 & D.5932;
  if (D.5933 != 0) goto <D.5934>; else goto <D.5935>;
  <D.5934>:
  {
    binmap_t leftbits;

    idx.20 = (int) idx;
    D.5937 = 1 << idx.20;
    D.5938 = D.5937 << 1;
    idx.20 = (int) idx;
    D.5937 = 1 << idx.20;
    D.5938 = D.5937 << 1;
    D.5939 = -D.5938;
    D.5940 = D.5938 | D.5939;
    D.5941 = m->treemap;
    leftbits = D.5940 & D.5941;
    if (leftbits != 0) goto <D.5942>; else goto <D.5943>;
    <D.5942>:
    {
      bindex_t i;
      binmap_t leastbit;

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

        Y = leastbit + 4294967295;
        D.5945 = Y >> 12;
        K = D.5945 & 16;
        N = K;
        K.21 = (int) K;
        Y = Y >> K.21;
        D.5947 = Y >> 5;
        K = D.5947 & 8;
        K.22 = K;
        N = K.22 + N;
        K.21 = (int) K;
        Y = Y >> K.21;
        D.5949 = Y >> 2;
        K = D.5949 & 4;
        K.23 = K;
        N = K.23 + N;
        K.21 = (int) K;
        Y = Y >> K.21;
        D.5951 = Y >> 1;
        K = D.5951 & 2;
        K.24 = K;
        N = K.24 + N;
        K.21 = (int) K;
        Y = Y >> K.21;
        D.5951 = Y >> 1;
        K = D.5951 & 1;
        K.25 = K;
        N = K.25 + N;
        K.21 = (int) K;
        Y = Y >> K.21;
        i = N + Y;
      }
      t = m->treebins[i];
    }
    <D.5943>:
  }
  <D.5935>:
  goto <D.5408>;
  <D.5407>:
  {
    size_t trem;

    D.5918 = t->head;
    D.5919 = D.5918 & 18446744073709551612;
    trem = D.5919 - nb;
    if (trem < rsize) goto <D.5954>; else goto <D.5955>;
    <D.5954>:
    rsize = trem;
    v = t;
    <D.5955>:
    D.5957 = t->child[0];
    if (D.5957 != 0B) goto <D.5958>; else goto <D.5959>;
    <D.5958>:
    iftmp.26 = t->child[0];
    goto <D.5960>;
    <D.5959>:
    iftmp.26 = t->child[1];
    <D.5960>:
    t = iftmp.26;
  }
  <D.5408>:
  if (t != 0B) goto <D.5407>; else goto <D.5409>;
  <D.5409>:
  if (v != 0B) goto <D.5961>; else goto <D.5962>;
  <D.5961>:
  D.5963 = m->dvsize;
  D.5964 = D.5963 - nb;
  if (D.5964 > rsize) goto <D.5965>; else goto <D.5966>;
  <D.5965>:
  D.5967 = m->least_addr;
  D.5968 = D.5967 <= v;
  D.5969 = (long int) D.5968;
  D.5970 = __builtin_expect (D.5969, 1);
  if (D.5970 != 0) goto <D.5971>; else goto <D.5972>;
  <D.5971>:
  {
    struct malloc_chunk * r;

    r = v + nb;
    D.5973 = v < r;
    D.5974 = (long int) D.5973;
    D.5975 = __builtin_expect (D.5974, 1);
    if (D.5975 != 0) goto <D.5976>; else goto <D.5977>;
    <D.5976>:
    {
      struct malloc_tree_chunk * XP;
      struct malloc_tree_chunk * R;

      XP = v->parent;
      D.5978 = v->bk;
      if (D.5978 != v) goto <D.5979>; else goto <D.5980>;
      <D.5979>:
      {
        struct malloc_tree_chunk * F;

        F = v->fd;
        R = v->bk;
        D.5967 = m->least_addr;
        D.5981 = D.5967 <= F;
        D.5982 = (long int) D.5981;
        D.5983 = __builtin_expect (D.5982, 1);
        if (D.5983 != 0) goto <D.5984>; else goto <D.5985>;
        <D.5984>:
        F->bk = R;
        R->fd = F;
        goto <D.5986>;
        <D.5985>:
        abort ();
        <D.5986>:
      }
      goto <D.5987>;
      <D.5980>:
      {
        struct malloc_tree_chunk * * RP;

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

          goto <D.5417>;
          <D.5416>:
          RP = CP;
          R = *RP;
          <D.5417>:
          CP = &R->child[1];
          D.5991 = *CP;
          if (D.5991 != 0B) goto <D.5416>; else goto <D.5992>;
          <D.5992>:
          CP = &R->child[0];
          D.5991 = *CP;
          if (D.5991 != 0B) goto <D.5416>; else goto <D.5418>;
          <D.5418>:
          D.5967 = m->least_addr;
          D.5993 = D.5967 <= RP;
          D.5994 = (long int) D.5993;
          D.5995 = __builtin_expect (D.5994, 1);
          if (D.5995 != 0) goto <D.5996>; else goto <D.5997>;
          <D.5996>:
          *RP = 0B;
          goto <D.5998>;
          <D.5997>:
          abort ();
          <D.5998>:
        }
        <D.5989>:
      }
      <D.5987>:
      if (XP != 0B) goto <D.5999>; else goto <D.6000>;
      <D.5999>:
      {
        struct malloc_tree_chunk * * H;

        D.6001 = v->index;
        H = &m->treebins[D.6001];
        D.6002 = *H;
        if (D.6002 == v) goto <D.6003>; else goto <D.6004>;
        <D.6003>:
        *H = R;
        D.6002 = *H;
        if (D.6002 == 0B) goto <D.6005>; else goto <D.6006>;
        <D.6005>:
        D.5941 = m->treemap;
        D.6001 = v->index;
        D.6007 = (int) D.6001;
        D.6008 = 1 << D.6007;
        D.6009 = ~D.6008;
        D.6010 = D.5941 & D.6009;
        m->treemap = D.6010;
        <D.6006>:
        goto <D.6011>;
        <D.6004>:
        D.5967 = m->least_addr;
        D.6012 = D.5967 <= XP;
        D.6013 = (long int) D.6012;
        D.6014 = __builtin_expect (D.6013, 1);
        if (D.6014 != 0) goto <D.6015>; else goto <D.6016>;
        <D.6015>:
        D.6017 = XP->child[0];
        if (D.6017 == v) goto <D.6018>; else goto <D.6019>;
        <D.6018>:
        XP->child[0] = R;
        goto <D.6020>;
        <D.6019>:
        XP->child[1] = R;
        <D.6020>:
        goto <D.6021>;
        <D.6016>:
        abort ();
        <D.6021>:
        <D.6011>:
        if (R != 0B) goto <D.6022>; else goto <D.6023>;
        <D.6022>:
        D.5967 = m->least_addr;
        D.6024 = D.5967 <= R;
        D.6025 = (long int) D.6024;
        D.6026 = __builtin_expect (D.6025, 1);
        if (D.6026 != 0) goto <D.6027>; else goto <D.6028>;
        <D.6027>:
        {
          struct malloc_tree_chunk * C0;
          struct malloc_tree_chunk * C1;

          R->parent = XP;
          C0 = v->child[0];
          if (C0 != 0B) goto <D.6029>; else goto <D.6030>;
          <D.6029>:
          D.5967 = m->least_addr;
          D.6031 = D.5967 <= C0;
          D.6032 = (long int) D.6031;
          D.6033 = __builtin_expect (D.6032, 1);
          if (D.6033 != 0) goto <D.6034>; else goto <D.6035>;
          <D.6034>:
          R->child[0] = C0;
          C0->parent = R;
          goto <D.6036>;
          <D.6035>:
          abort ();
          <D.6036>:
          <D.6030>:
          C1 = v->child[1];
          if (C1 != 0B) goto <D.6037>; else goto <D.6038>;
          <D.6037>:
          D.5967 = m->least_addr;
          D.6039 = D.5967 <= C1;
          D.6040 = (long int) D.6039;
          D.6041 = __builtin_expect (D.6040, 1);
          if (D.6041 != 0) goto <D.6042>; else goto <D.6043>;
          <D.6042>:
          R->child[1] = C1;
          C1->parent = R;
          goto <D.6044>;
          <D.6043>:
          abort ();
          <D.6044>:
          <D.6038>:
        }
        goto <D.6045>;
        <D.6028>:
        abort ();
        <D.6045>:
        <D.6023>:
      }
      <D.6000>:
    }
    if (rsize <= 31) goto <D.6046>; else goto <D.6047>;
    <D.6046>:
    D.6048 = rsize + nb;
    D.6049 = D.6048 | 3;
    v->head = D.6049;
    D.6048 = rsize + nb;
    D.6050 = v + D.6048;
    D.6048 = rsize + nb;
    D.6050 = v + D.6048;
    D.6051 = D.6050->head;
    D.6052 = D.6051 | 1;
    D.6050->head = D.6052;
    goto <D.6053>;
    <D.6047>:
    D.6054 = nb | 3;
    v->head = D.6054;
    D.6055 = rsize | 1;
    r->head = D.6055;
    D.6056 = r + rsize;
    D.6056->prev_foot = rsize;
    D.6057 = rsize >> 3;
    if (D.6057 <= 31) goto <D.6058>; else goto <D.6059>;
    <D.6058>:
    {
      bindex_t I;
      struct malloc_chunk * B;
      struct malloc_chunk * F;

      D.6057 = rsize >> 3;
      I = (bindex_t) D.6057;
      D.6060 = I << 1;
      B = &m->smallbins[D.6060];
      F = B;
      D.6061 = m->smallmap;
      I.27 = (int) I;
      D.6063 = 1 << I.27;
      D.6064 = D.6061 & D.6063;
      if (D.6064 == 0) goto <D.6065>; else goto <D.6066>;
      <D.6065>:
      D.6061 = m->smallmap;
      I.27 = (int) I;
      D.6063 = 1 << I.27;
      D.6067 = D.6061 | D.6063;
      m->smallmap = D.6067;
      goto <D.6068>;
      <D.6066>:
      D.6069 = B->fd;
      D.5967 = m->least_addr;
      D.6070 = D.6069 >= D.5967;
      D.6071 = (long int) D.6070;
      D.6072 = __builtin_expect (D.6071, 1);
      if (D.6072 != 0) goto <D.6073>; else goto <D.6074>;
      <D.6073>:
      F = B->fd;
      goto <D.6075>;
      <D.6074>:
      abort ();
      <D.6075>:
      <D.6068>:
      B->fd = r;
      F->bk = r;
      r->fd = F;
      r->bk = B;
    }
    goto <D.6076>;
    <D.6059>:
    {
      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.6077>; else goto <D.6078>;
          <D.6077>:
          I = 0;
          goto <D.6079>;
          <D.6078>:
          if (X > 65535) goto <D.6080>; else goto <D.6081>;
          <D.6080>:
          I = 31;
          goto <D.6082>;
          <D.6081>:
          {
            unsigned int Y;
            unsigned int N;
            unsigned int K;

            Y = (unsigned int) X;
            D.6083 = Y + 4294967040;
            D.6084 = D.6083 >> 16;
            N = D.6084 & 8;
            N.28 = (int) N;
            Y = Y << N.28;
            D.6086 = Y + 4294963200;
            D.6087 = D.6086 >> 16;
            K = D.6087 & 4;
            N = N + K;
            K.29 = (int) K;
            Y = Y << K.29;
            D.6089 = Y + 4294950912;
            D.6090 = D.6089 >> 16;
            K = D.6090 & 2;
            K.30 = K;
            N = K.30 + N;
            K.29 = (int) K;
            Y = Y << K.29;
            D.6092 = Y >> 15;
            D.6093 = D.6092 - N;
            K = D.6093 + 14;
            D.6094 = K << 1;
            D.6095 = K + 7;
            D.6096 = (int) D.6095;
            D.6097 = rsize >> D.6096;
            D.6098 = (unsigned int) D.6097;
            D.6099 = D.6098 & 1;
            I = D.6094 + D.6099;
          }
          <D.6082>:
          <D.6079>:
        }
        H = &m->treebins[I];
        TP->index = I;
        TP->child[1] = 0B;
        D.6100 = TP->child[1];
        TP->child[0] = D.6100;
        D.5941 = m->treemap;
        I.31 = (int) I;
        D.6102 = 1 << I.31;
        D.6103 = D.5941 & D.6102;
        if (D.6103 == 0) goto <D.6104>; else goto <D.6105>;
        <D.6104>:
        D.5941 = m->treemap;
        I.31 = (int) I;
        D.6102 = 1 << I.31;
        D.6106 = D.5941 | D.6102;
        m->treemap = D.6106;
        *H = TP;
        TP->parent = H;
        TP->bk = TP;
        D.6107 = TP->bk;
        TP->fd = D.6107;
        goto <D.6108>;
        <D.6105>:
        {
          struct malloc_tree_chunk * T;
          size_t K;

          T = *H;
          if (I != 31) goto <D.6110>; else goto <D.6111>;
          <D.6110>:
          D.6112 = I >> 1;
          D.6113 = D.6112 + 6;
          D.6114 = (long unsigned int) D.6113;
          D.6115 = 63 - D.6114;
          iftmp.32 = (int) D.6115;
          goto <D.6116>;
          <D.6111>:
          iftmp.32 = 0;
          <D.6116>:
          K = rsize << iftmp.32;
          <D.5437>:
          D.6117 = T->head;
          D.6118 = D.6117 & 18446744073709551612;
          if (D.6118 != rsize) goto <D.6119>; else goto <D.6120>;
          <D.6119>:
          {
            struct malloc_tree_chunk * * C;

            D.6121 = K >> 63;
            C = &T->child[D.6121];
            K = K << 1;
            D.6122 = *C;
            if (D.6122 != 0B) goto <D.6123>; else goto <D.6124>;
            <D.6123>:
            T = *C;
            goto <D.6125>;
            <D.6124>:
            D.5967 = m->least_addr;
            D.6126 = D.5967 <= C;
            D.6127 = (long int) D.6126;
            D.6128 = __builtin_expect (D.6127, 1);
            if (D.6128 != 0) goto <D.6129>; else goto <D.6130>;
            <D.6129>:
            *C = TP;
            TP->parent = T;
            TP->bk = TP;
            D.6107 = TP->bk;
            TP->fd = D.6107;
            goto <D.5435>;
            <D.6130>:
            abort ();
            <D.6125>:
          }
          goto <D.6131>;
          <D.6120>:
          {
            struct malloc_tree_chunk * F;

            F = T->fd;
            D.5967 = m->least_addr;
            D.6133 = D.5967 <= T;
            D.6134 = (long int) D.6133;
            D.6135 = __builtin_expect (D.6134, 1);
            if (D.6135 != 0) goto <D.6136>; else goto <D.6132>;
            <D.6136>:
            D.5967 = m->least_addr;
            D.6137 = D.5967 <= F;
            D.6138 = (long int) D.6137;
            D.6139 = __builtin_expect (D.6138, 1);
            if (D.6139 != 0) goto <D.6140>; else goto <D.6132>;
            <D.6140>:
            F->bk = TP;
            D.6141 = F->bk;
            T->fd = D.6141;
            TP->fd = F;
            TP->bk = T;
            TP->parent = 0B;
            goto <D.5435>;
            <D.6132>:
            abort ();
          }
          <D.6131>:
          goto <D.5437>;
          <D.5435>:
        }
        <D.6108>:
      }
    }
    <D.6076>:
    <D.6053>:
    D.6142 = v + 16;
    return D.6142;
    <D.5977>:
  }
  <D.5972>:
  abort ();
  <D.5966>:
  <D.5962>:
  D.6142 = 0B;
  return D.6142;
}


sys_alloc (struct malloc_state * m, size_t nb)
{
  unsigned int D.6144;
  long unsigned int D.6145;
  long unsigned int D.6146;
  long unsigned int D.6149;
  void * D.6154;
  struct malloc_segment * iftmp.33;
  struct malloc_chunk * D.6158;
  long unsigned int D.6166;
  long unsigned int D.6167;
  long unsigned int D.6168;
  long unsigned int D.6169;
  long unsigned int D.6170;
  long unsigned int D.6171;
  long unsigned int base.34;
  long unsigned int D.6173;
  long unsigned int D.6176;
  long unsigned int D.6177;
  long unsigned int D.6178;
  long unsigned int D.6179;
  long unsigned int D.6185;
  long unsigned int D.6186;
  long unsigned int D.6187;
  long unsigned int D.6188;
  char * D.6191;
  long unsigned int D.6192;
  char * D.6193;
  long unsigned int D.6202;
  long unsigned int D.6205;
  long unsigned int D.6206;
  long unsigned int D.6207;
  unsigned int D.6216;
  long unsigned int D.6219;
  _Bool D.6228;
  _Bool D.6229;
  _Bool D.6230;
  long int end.35;
  long int br.36;
  long int D.6237;
  long unsigned int D.6238;
  long unsigned int D.6243;
  long unsigned int D.6244;
  long unsigned int D.6245;
  char * D.6250;
  long unsigned int D.6251;
  long unsigned int D.6254;
  struct malloc_chunk * D.6256;
  long unsigned int D.6257;
  sizetype D.6258;
  sizetype D.6259;
  char * D.6260;
  long int D.6261;
  long int mn.37;
  long int D.6263;
  long unsigned int D.6264;
  long unsigned int D.6265;
  char * D.6268;
  long unsigned int D.6269;
  char * D.6270;
  unsigned int D.6274;
  unsigned int D.6275;
  long unsigned int D.6277;
  long unsigned int D.6278;
  long unsigned int D.6279;
  long unsigned int D.6283;
  long unsigned int D.6284;
  long unsigned int D.6294;
  struct malloc_chunk * D.6295;
  long unsigned int D.6296;
  long unsigned int D.6297;
  int * D.6298;
  char * tbase;
  size_t tsize;
  flag_t mmap_flag;

  tbase = -1B;
  tsize = 0;
  mmap_flag = 0;
  init_mparams ();
  D.6144 = m->mflags;
  D.6145 = (long unsigned int) D.6144;
  D.6146 = D.6145 & 1;
  if (D.6146 != 0) goto <D.6147>; else goto <D.6148>;
  <D.6147>:
  D.6149 = mparams.mmap_threshold;
  if (D.6149 <= nb) goto <D.6150>; else goto <D.6151>;
  <D.6150>:
  {
    void * mem;

    mem = mmap_alloc (m, nb);
    if (mem != 0B) goto <D.6152>; else goto <D.6153>;
    <D.6152>:
    D.6154 = mem;
    return D.6154;
    <D.6153>:
  }
  <D.6151>:
  <D.6148>:
  if (0 != 0) goto <D.6155>; else goto <D.6156>;
  <D.6155>:
  {
    char * br;
    struct malloc_segment * ss;
    size_t asize;

    br = -1B;
    D.6158 = m->top;
    if (D.6158 != 0B) goto <D.6159>; else goto <D.6160>;
    <D.6159>:
    D.6158 = m->top;
    iftmp.33 = segment_holding (m, D.6158);
    goto <D.6161>;
    <D.6160>:
    iftmp.33 = 0B;
    <D.6161>:
    ss = iftmp.33;
    asize = 0;
    if (ss == 0B) goto <D.6162>; else goto <D.6163>;
    <D.6162>:
    {
      char * base;

      base = -1B;
      if (base != -1B) goto <D.6164>; else goto <D.6165>;
      <D.6164>:
      D.6166 = mparams.granularity;
      D.6167 = D.6166 + nb;
      D.6168 = D.6167 + 73;
      D.6166 = mparams.granularity;
      D.6169 = -D.6166;
      asize = D.6168 & D.6169;
      D.6170 = mparams.page_size;
      D.6171 = D.6170 + 18446744073709551615;
      base.34 = (long unsigned int) base;
      D.6173 = D.6171 & base.34;
      if (D.6173 != 0) goto <D.6174>; else goto <D.6175>;
      <D.6174>:
      D.6170 = mparams.page_size;
      base.34 = (long unsigned int) base;
      D.6176 = D.6170 + base.34;
      D.6170 = mparams.page_size;
      D.6177 = -D.6170;
      D.6178 = D.6176 & D.6177;
      base.34 = (long unsigned int) base;
      D.6179 = D.6178 - base.34;
      asize = D.6179 + asize;
      <D.6175>:
      if (asize <= 9223372036854775806) goto <D.6180>; else goto <D.6181>;
      <D.6180>:
      br = -1B;
      if (br == base) goto <D.6182>; else goto <D.6183>;
      <D.6182>:
      tbase = base;
      tsize = asize;
      <D.6183>:
      <D.6181>:
      <D.6165>:
    }
    goto <D.6184>;
    <D.6163>:
    D.6185 = m->topsize;
    D.6186 = nb - D.6185;
    D.6166 = mparams.granularity;
    D.6187 = D.6186 + D.6166;
    D.6188 = D.6187 + 73;
    D.6166 = mparams.granularity;
    D.6169 = -D.6166;
    asize = D.6188 & D.6169;
    if (asize <= 9223372036854775806) goto <D.6189>; else goto <D.6190>;
    <D.6189>:
    br = -1B;
    D.6191 = ss->base;
    D.6192 = ss->size;
    D.6193 = D.6191 + D.6192;
    if (br == D.6193) goto <D.6194>; else goto <D.6195>;
    <D.6194>:
    tbase = br;
    tsize = asize;
    <D.6195>:
    <D.6190>:
    <D.6184>:
    if (tbase == -1B) goto <D.6196>; else goto <D.6197>;
    <D.6196>:
    if (br != -1B) goto <D.6198>; else goto <D.6199>;
    <D.6198>:
    if (asize <= 9223372036854775806) goto <D.6200>; else goto <D.6201>;
    <D.6200>:
    D.6202 = nb + 73;
    if (D.6202 > asize) goto <D.6203>; else goto <D.6204>;
    <D.6203>:
    {
      size_t esize;

      D.6205 = nb - asize;
      D.6166 = mparams.granularity;
      D.6206 = D.6205 + D.6166;
      D.6207 = D.6206 + 73;
      D.6166 = mparams.granularity;
      D.6169 = -D.6166;
      esize = D.6207 & D.6169;
      if (esize <= 9223372036854775806) goto <D.6208>; else goto <D.6209>;
      <D.6208>:
      {
        char * end;

        end = -1B;
        if (end != -1B) goto <D.6210>; else goto <D.6211>;
        <D.6210>:
        asize = asize + esize;
        goto <D.6212>;
        <D.6211>:
        br = -1B;
        <D.6212>:
      }
      <D.6209>:
    }
    <D.6204>:
    <D.6201>:
    <D.6199>:
    if (br != -1B) goto <D.6213>; else goto <D.6214>;
    <D.6213>:
    tbase = br;
    tsize = asize;
    goto <D.6215>;
    <D.6214>:
    D.6144 = m->mflags;
    D.6216 = D.6144 | 4;
    m->mflags = D.6216;
    <D.6215>:
    <D.6197>:
  }
  <D.6156>:
  if (tbase == -1B) goto <D.6217>; else goto <D.6218>;
  <D.6217>:
  {
    size_t req;
    size_t rsize;

    req = nb + 73;
    D.6166 = mparams.granularity;
    D.6219 = D.6166 + req;
    D.6166 = mparams.granularity;
    D.6169 = -D.6166;
    rsize = D.6219 & D.6169;
    if (rsize > nb) goto <D.6220>; else goto <D.6221>;
    <D.6220>:
    {
      char * mp;

      mp = mmap (0B, rsize, 7, 34, -1, 0);
      if (mp != -1B) goto <D.6222>; else goto <D.6223>;
      <D.6222>:
      tbase = mp;
      tsize = rsize;
      mmap_flag = 1;
      <D.6223>:
    }
    <D.6221>:
  }
  <D.6218>:
  if (0 != 0) goto <D.6224>; else goto <D.6225>;
  <D.6224>:
  {
    size_t asize;

    D.6166 = mparams.granularity;
    D.6167 = D.6166 + nb;
    D.6168 = D.6167 + 73;
    D.6166 = mparams.granularity;
    D.6169 = -D.6166;
    asize = D.6168 & D.6169;
    if (asize <= 9223372036854775806) goto <D.6226>; else goto <D.6227>;
    <D.6226>:
    {
      char * br;
      char * end;

      br = -1B;
      end = -1B;
      br = -1B;
      end = -1B;
      D.6228 = br != -1B;
      D.6229 = end != -1B;
      D.6230 = D.6228 & D.6229;
      if (D.6230 != 0) goto <D.6231>; else goto <D.6232>;
      <D.6231>:
      if (br < end) goto <D.6233>; else goto <D.6234>;
      <D.6233>:
      {
        size_t ssize;

        end.35 = (long int) end;
        br.36 = (long int) br;
        D.6237 = end.35 - br.36;
        ssize = (size_t) D.6237;
        D.6238 = nb + 72;
        if (D.6238 < ssize) goto <D.6239>; else goto <D.6240>;
        <D.6239>:
        tbase = br;
        tsize = ssize;
        <D.6240>:
      }
      <D.6234>:
      <D.6232>:
    }
    <D.6227>:
  }
  <D.6225>:
  if (tbase != -1B) goto <D.6241>; else goto <D.6242>;
  <D.6241>:
  D.6243 = m->footprint;
  D.6244 = D.6243 + tsize;
  m->footprint = D.6244;
  D.6243 = m->footprint;
  D.6245 = m->max_footprint;
  if (D.6243 > D.6245) goto <D.6246>; else goto <D.6247>;
  <D.6246>:
  D.6243 = m->footprint;
  m->max_footprint = D.6243;
  <D.6247>:
  D.6158 = m->top;
  if (D.6158 == 0B) goto <D.6248>; else goto <D.6249>;
  <D.6248>:
  m->least_addr = tbase;
  D.6250 = m->least_addr;
  m->seg.base = D.6250;
  m->seg.size = tsize;
  m->seg.sflags = mmap_flag;
  D.6251 = mparams.magic;
  m->magic = D.6251;
  init_bins (m);
  if (m == &_gm_) goto <D.6252>; else goto <D.6253>;
  <D.6252>:
  D.6254 = tsize + 18446744073709551544;
  init_top (m, tbase, D.6254);
  goto <D.6255>;
  <D.6253>:
  {
    struct malloc_chunk * mn;

    D.6256 = m + 18446744073709551600;
    D.6257 = D.6256->head;
    D.6258 = D.6257 & 18446744073709551612;
    D.6259 = D.6258 + 18446744073709551600;
    mn = m + D.6259;
    D.6260 = tbase + tsize;
    D.6261 = (long int) D.6260;
    mn.37 = (long int) mn;
    D.6263 = D.6261 - mn.37;
    D.6264 = (long unsigned int) D.6263;
    D.6265 = D.6264 + 18446744073709551544;
    init_top (m, mn, D.6265);
  }
  <D.6255>:
  goto <D.6266>;
  <D.6249>:
  {
    struct malloc_segment * sp;

    sp = &m->seg;
    goto <D.5323>;
    <D.5322>:
    sp = sp->next;
    <D.5323>:
    if (sp != 0B) goto <D.6267>; else goto <D.5324>;
    <D.6267>:
    D.6268 = sp->base;
    D.6269 = sp->size;
    D.6270 = D.6268 + D.6269;
    if (D.6270 != tbase) goto <D.5322>; else goto <D.5324>;
    <D.5324>:
    if (sp != 0B) goto <D.6273>; else goto <D.6271>;
    <D.6273>:
    D.6274 = sp->sflags;
    D.6275 = D.6274 & 8;
    if (D.6275 == 0) goto <D.6276>; else goto <D.6271>;
    <D.6276>:
    D.6274 = sp->sflags;
    D.6277 = (long unsigned int) D.6274;
    D.6278 = D.6277 & 1;
    D.6279 = (long unsigned int) mmap_flag;
    if (D.6278 == D.6279) goto <D.6280>; else goto <D.6271>;
    <D.6280>:
    D.6158 = m->top;
    D.6268 = sp->base;
    if (D.6158 >= D.6268) goto <D.6281>; else goto <D.6271>;
    <D.6281>:
    D.6158 = m->top;
    D.6268 = sp->base;
    D.6269 = sp->size;
    D.6270 = D.6268 + D.6269;
    if (D.6158 < D.6270) goto <D.6282>; else goto <D.6271>;
    <D.6282>:
    D.6269 = sp->size;
    D.6283 = D.6269 + tsize;
    sp->size = D.6283;
    D.6185 = m->topsize;
    D.6284 = D.6185 + tsize;
    D.6158 = m->top;
    init_top (m, D.6158, D.6284);
    goto <D.6272>;
    <D.6271>:
    D.6250 = m->least_addr;
    if (D.6250 > tbase) goto <D.6285>; else goto <D.6286>;
    <D.6285>:
    m->least_addr = tbase;
    <D.6286>:
    sp = &m->seg;
    goto <D.5326>;
    <D.5325>:
    sp = sp->next;
    <D.5326>:
    if (sp != 0B) goto <D.6287>; else goto <D.5327>;
    <D.6287>:
    D.6268 = sp->base;
    D.6260 = tbase + tsize;
    if (D.6268 != D.6260) goto <D.5325>; else goto <D.5327>;
    <D.5327>:
    if (sp != 0B) goto <D.6289>; else goto <D.6288>;
    <D.6289>:
    D.6274 = sp->sflags;
    D.6275 = D.6274 & 8;
    if (D.6275 == 0) goto <D.6290>; else goto <D.6288>;
    <D.6290>:
    D.6274 = sp->sflags;
    D.6277 = (long unsigned int) D.6274;
    D.6278 = D.6277 & 1;
    D.6279 = (long unsigned int) mmap_flag;
    if (D.6278 == D.6279) goto <D.6291>; else goto <D.6288>;
    <D.6291>:
    {
      char * oldbase;

      oldbase = sp->base;
      sp->base = tbase;
      D.6269 = sp->size;
      D.6283 = D.6269 + tsize;
      sp->size = D.6283;
      D.6154 = prepend_alloc (m, tbase, oldbase, nb);
      return D.6154;
    }
    <D.6288>:
    add_segment (m, tbase, tsize, mmap_flag);
    <D.6272>:
  }
  <D.6266>:
  D.6185 = m->topsize;
  if (D.6185 > nb) goto <D.6292>; else goto <D.6293>;
  <D.6292>:
  {
    size_t rsize;
    struct malloc_chunk * p;
    struct malloc_chunk * r;

    D.6185 = m->topsize;
    D.6294 = D.6185 - nb;
    m->topsize = D.6294;
    rsize = m->topsize;
    p = m->top;
    D.6295 = p + nb;
    m->top = D.6295;
    r = m->top;
    D.6296 = rsize | 1;
    r->head = D.6296;
    D.6297 = nb | 3;
    p->head = D.6297;
    D.6154 = p + 16;
    return D.6154;
  }
  <D.6293>:
  <D.6242>:
  D.6298 = __errno_location ();
  *D.6298 = 12;
  D.6154 = 0B;
  return D.6154;
}


mmap_alloc (struct malloc_state * m, size_t nb)
{
  long unsigned int D.6300;
  long unsigned int D.6301;
  long unsigned int D.6302;
  long unsigned int D.6303;
  long unsigned int iftmp.38;
  void * D.6309;
  long unsigned int D.6310;
  long unsigned int D.6311;
  long unsigned int D.6314;
  long unsigned int D.6316;
  long unsigned int D.6317;
  long unsigned int D.6318;
  struct malloc_chunk * D.6319;
  sizetype D.6320;
  struct malloc_chunk * D.6321;
  char * D.6322;
  long unsigned int D.6325;
  long unsigned int D.6326;
  long unsigned int D.6327;
  void * D.6330;
  size_t mmsize;

  D.6300 = mparams.granularity;
  D.6301 = D.6300 + nb;
  D.6302 = D.6301 + 55;
  D.6300 = mparams.granularity;
  D.6303 = -D.6300;
  mmsize = D.6302 & D.6303;
  if (mmsize > nb) goto <D.6304>; else goto <D.6305>;
  <D.6304>:
  {
    char * mm;

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

      D.6309 = mm + 16;
      D.6310 = (long unsigned int) D.6309;
      D.6311 = D.6310 & 7;
      if (D.6311 != 0) goto <D.6312>; else goto <D.6313>;
      <D.6312>:
      D.6309 = mm + 16;
      D.6310 = (long unsigned int) D.6309;
      D.6314 = -D.6310;
      iftmp.38 = D.6314 & 7;
      goto <D.6315>;
      <D.6313>:
      iftmp.38 = 0;
      <D.6315>:
      offset = iftmp.38;
      D.6316 = mmsize - offset;
      psize = D.6316 + 18446744073709551584;
      p = mm + offset;
      D.6317 = offset | 1;
      p->prev_foot = D.6317;
      D.6318 = psize | 2;
      p->head = D.6318;
      D.6319 = p + psize;
      D.6319->head = 11;
      D.6320 = psize + 8;
      D.6321 = p + D.6320;
      D.6321->head = 0;
      D.6322 = m->least_addr;
      if (D.6322 > mm) goto <D.6323>; else goto <D.6324>;
      <D.6323>:
      m->least_addr = mm;
      <D.6324>:
      D.6325 = m->footprint;
      D.6326 = D.6325 + mmsize;
      m->footprint = D.6326;
      D.6325 = m->footprint;
      D.6327 = m->max_footprint;
      if (D.6325 > D.6327) goto <D.6328>; else goto <D.6329>;
      <D.6328>:
      D.6325 = m->footprint;
      m->max_footprint = D.6325;
      <D.6329>:
      D.6330 = p + 16;
      return D.6330;
    }
    <D.6307>:
  }
  <D.6305>:
  D.6330 = 0B;
  return D.6330;
}


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

  i = 0;
  goto <D.5211>;
  <D.5210>:
  {
    struct malloc_chunk * bin;

    D.6332 = i << 1;
    bin = &m->smallbins[D.6332];
    bin->bk = bin;
    D.6333 = bin->bk;
    bin->fd = D.6333;
  }
  i = i + 1;
  <D.5211>:
  if (i <= 31) goto <D.5210>; else goto <D.5212>;
  <D.5212>:
}


init_top (struct malloc_state * m, struct malloc_chunk * p, size_t psize)
{
  long unsigned int iftmp.39;
  void * D.6335;
  long unsigned int D.6336;
  long unsigned int D.6337;
  long unsigned int D.6340;
  long unsigned int D.6342;
  struct malloc_chunk * D.6343;
  long unsigned int D.6344;
  size_t offset;

  D.6335 = p + 16;
  D.6336 = (long unsigned int) D.6335;
  D.6337 = D.6336 & 7;
  if (D.6337 != 0) goto <D.6338>; else goto <D.6339>;
  <D.6338>:
  D.6335 = p + 16;
  D.6336 = (long unsigned int) D.6335;
  D.6340 = -D.6336;
  iftmp.39 = D.6340 & 7;
  goto <D.6341>;
  <D.6339>:
  iftmp.39 = 0;
  <D.6341>:
  offset = iftmp.39;
  p = p + offset;
  psize = psize - offset;
  m->top = p;
  m->topsize = psize;
  D.6342 = psize | 1;
  p->head = D.6342;
  D.6343 = p + psize;
  D.6343->head = 72;
  D.6344 = mparams.trim_threshold;
  m->trim_check = D.6344;
}


prepend_alloc (struct malloc_state * m, char * newbase, char * oldbase, size_t nb)
{
  sizetype iftmp.40;
  void * D.6346;
  long unsigned int D.6347;
  long unsigned int D.6348;
  long unsigned int D.6351;
  sizetype iftmp.41;
  void * D.6354;
  long unsigned int D.6355;
  long unsigned int D.6356;
  long unsigned int D.6359;
  long int oldfirst.42;
  long int p.43;
  long int D.6363;
  long unsigned int D.6364;
  struct malloc_chunk * D.6365;
  long unsigned int D.6368;
  long unsigned int D.6369;
  long unsigned int D.6370;
  struct malloc_chunk * D.6372;
  long unsigned int D.6375;
  long unsigned int D.6376;
  long unsigned int D.6377;
  struct malloc_chunk * D.6378;
  long unsigned int D.6380;
  long unsigned int D.6381;
  long unsigned int D.6384;
  unsigned int D.6389;
  int I.44;
  unsigned int D.6391;
  unsigned int D.6392;
  unsigned int D.6393;
  int iftmp.45;
  unsigned int D.6401;
  struct malloc_chunk * * D.6402;
  _Bool D.6403;
  long int D.6404;
  long int D.6405;
  char * D.6407;
  _Bool D.6408;
  long int D.6409;
  long int D.6410;
  int iftmp.46;
  _Bool D.6416;
  long int D.6417;
  long int D.6418;
  _Bool D.6420;
  long int D.6421;
  long int D.6422;
  struct malloc_tree_chunk * D.6425;
  _Bool D.6428;
  long int D.6429;
  long int D.6430;
  struct malloc_tree_chunk * D.6438;
  _Bool D.6440;
  long int D.6441;
  long int D.6442;
  unsigned int D.6448;
  struct malloc_tree_chunk * D.6449;
  unsigned int D.6454;
  int D.6455;
  unsigned int D.6456;
  unsigned int D.6457;
  unsigned int D.6458;
  _Bool D.6460;
  long int D.6461;
  long int D.6462;
  struct malloc_tree_chunk * D.6465;
  _Bool D.6472;
  long int D.6473;
  long int D.6474;
  _Bool D.6479;
  long int D.6480;
  long int D.6481;
  _Bool D.6487;
  long int D.6488;
  long int D.6489;
  long unsigned int D.6494;
  long unsigned int D.6495;
  struct malloc_chunk * D.6496;
  long unsigned int D.6497;
  unsigned int D.6500;
  int I.47;
  unsigned int D.6502;
  unsigned int D.6503;
  unsigned int D.6506;
  struct malloc_chunk * D.6508;
  _Bool D.6509;
  long int D.6510;
  long int D.6511;
  unsigned int D.6522;
  unsigned int D.6523;
  int N.48;
  unsigned int D.6525;
  unsigned int D.6526;
  int K.49;
  unsigned int D.6528;
  unsigned int D.6529;
  unsigned int K.50;
  unsigned int D.6531;
  unsigned int D.6532;
  unsigned int D.6533;
  unsigned int D.6534;
  int D.6535;
  long unsigned int D.6536;
  unsigned int D.6537;
  unsigned int D.6538;
  struct malloc_tree_chunk * D.6539;
  int I.51;
  unsigned int D.6541;
  unsigned int D.6542;
  unsigned int D.6545;
  struct malloc_tree_chunk * D.6546;
  int iftmp.52;
  unsigned int D.6551;
  unsigned int D.6552;
  long unsigned int D.6553;
  long unsigned int D.6554;
  long unsigned int D.6556;
  long unsigned int D.6557;
  long unsigned int D.6560;
  struct malloc_tree_chunk * D.6561;
  _Bool D.6565;
  long int D.6566;
  long int D.6567;
  _Bool D.6572;
  long int D.6573;
  long int D.6574;
  _Bool D.6576;
  long int D.6577;
  long int D.6578;
  struct malloc_tree_chunk * D.6580;
  void * D.6581;
  struct malloc_chunk * p;
  struct malloc_chunk * oldfirst;
  size_t psize;
  struct malloc_chunk * q;
  size_t qsize;

  D.6346 = newbase + 16;
  D.6347 = (long unsigned int) D.6346;
  D.6348 = D.6347 & 7;
  if (D.6348 != 0) goto <D.6349>; else goto <D.6350>;
  <D.6349>:
  D.6346 = newbase + 16;
  D.6347 = (long unsigned int) D.6346;
  D.6351 = -D.6347;
  iftmp.40 = D.6351 & 7;
  goto <D.6352>;
  <D.6350>:
  iftmp.40 = 0;
  <D.6352>:
  p = newbase + iftmp.40;
  D.6354 = oldbase + 16;
  D.6355 = (long unsigned int) D.6354;
  D.6356 = D.6355 & 7;
  if (D.6356 != 0) goto <D.6357>; else goto <D.6358>;
  <D.6357>:
  D.6354 = oldbase + 16;
  D.6355 = (long unsigned int) D.6354;
  D.6359 = -D.6355;
  iftmp.41 = D.6359 & 7;
  goto <D.6360>;
  <D.6358>:
  iftmp.41 = 0;
  <D.6360>:
  oldfirst = oldbase + iftmp.41;
  oldfirst.42 = (long int) oldfirst;
  p.43 = (long int) p;
  D.6363 = oldfirst.42 - p.43;
  psize = (size_t) D.6363;
  q = p + nb;
  qsize = psize - nb;
  D.6364 = nb | 3;
  p->head = D.6364;
  D.6365 = m->top;
  if (D.6365 == oldfirst) goto <D.6366>; else goto <D.6367>;
  <D.6366>:
  {
    size_t tsize;

    D.6368 = m->topsize;
    D.6369 = D.6368 + qsize;
    m->topsize = D.6369;
    tsize = m->topsize;
    m->top = q;
    D.6370 = tsize | 1;
    q->head = D.6370;
  }
  goto <D.6371>;
  <D.6367>:
  D.6372 = m->dv;
  if (D.6372 == oldfirst) goto <D.6373>; else goto <D.6374>;
  <D.6373>:
  {
    size_t dsize;

    D.6375 = m->dvsize;
    D.6376 = D.6375 + qsize;
    m->dvsize = D.6376;
    dsize = m->dvsize;
    m->dv = q;
    D.6377 = dsize | 1;
    q->head = D.6377;
    D.6378 = q + dsize;
    D.6378->prev_foot = dsize;
  }
  goto <D.6379>;
  <D.6374>:
  D.6380 = oldfirst->head;
  D.6381 = D.6380 & 2;
  if (D.6381 == 0) goto <D.6382>; else goto <D.6383>;
  <D.6382>:
  {
    size_t nsize;

    D.6380 = oldfirst->head;
    nsize = D.6380 & 18446744073709551612;
    D.6384 = nsize >> 3;
    if (D.6384 <= 31) goto <D.6385>; else goto <D.6386>;
    <D.6385>:
    {
      struct malloc_chunk * F;
      struct malloc_chunk * B;
      bindex_t I;

      F = oldfirst->fd;
      B = oldfirst->bk;
      D.6384 = nsize >> 3;
      I = (bindex_t) D.6384;
      if (F == B) goto <D.6387>; else goto <D.6388>;
      <D.6387>:
      D.6389 = m->smallmap;
      I.44 = (int) I;
      D.6391 = 1 << I.44;
      D.6392 = ~D.6391;
      D.6393 = D.6389 & D.6392;
      m->smallmap = D.6393;
      goto <D.6394>;
      <D.6388>:
      D.6401 = I << 1;
      D.6402 = &m->smallbins[D.6401];
      D.6403 = D.6402 == F;
      D.6404 = (long int) D.6403;
      D.6405 = __builtin_expect (D.6404, 1);
      if (D.6405 != 0) goto <D.6398>; else goto <D.6406>;
      <D.6406>:
      D.6407 = m->least_addr;
      D.6408 = D.6407 <= F;
      D.6409 = (long int) D.6408;
      D.6410 = __builtin_expect (D.6409, 1);
      if (D.6410 != 0) goto <D.6398>; else goto <D.6399>;
      <D.6398>:
      iftmp.45 = 1;
      goto <D.6400>;
      <D.6399>:
      iftmp.45 = 0;
      <D.6400>:
      if (iftmp.45 != 0) goto <D.6411>; else goto <D.6395>;
      <D.6411>:
      D.6401 = I << 1;
      D.6402 = &m->smallbins[D.6401];
      D.6416 = D.6402 == B;
      D.6417 = (long int) D.6416;
      D.6418 = __builtin_expect (D.6417, 1);
      if (D.6418 != 0) goto <D.6413>; else goto <D.6419>;
      <D.6419>:
      D.6407 = m->least_addr;
      D.6420 = D.6407 <= B;
      D.6421 = (long int) D.6420;
      D.6422 = __builtin_expect (D.6421, 1);
      if (D.6422 != 0) goto <D.6413>; else goto <D.6414>;
      <D.6413>:
      iftmp.46 = 1;
      goto <D.6415>;
      <D.6414>:
      iftmp.46 = 0;
      <D.6415>:
      if (iftmp.46 != 0) goto <D.6423>; else goto <D.6395>;
      <D.6423>:
      F->bk = B;
      B->fd = F;
      goto <D.6396>;
      <D.6395>:
      abort ();
      <D.6396>:
      <D.6394>:
    }
    goto <D.6424>;
    <D.6386>:
    {
      struct malloc_tree_chunk * TP;

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

        XP = TP->parent;
        D.6425 = TP->bk;
        if (D.6425 != TP) goto <D.6426>; else goto <D.6427>;
        <D.6426>:
        {
          struct malloc_tree_chunk * F;

          F = TP->fd;
          R = TP->bk;
          D.6407 = m->least_addr;
          D.6428 = D.6407 <= F;
          D.6429 = (long int) D.6428;
          D.6430 = __builtin_expect (D.6429, 1);
          if (D.6430 != 0) goto <D.6431>; else goto <D.6432>;
          <D.6431>:
          F->bk = R;
          R->fd = F;
          goto <D.6433>;
          <D.6432>:
          abort ();
          <D.6433>:
        }
        goto <D.6434>;
        <D.6427>:
        {
          struct malloc_tree_chunk * * RP;

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

            goto <D.5237>;
            <D.5236>:
            RP = CP;
            R = *RP;
            <D.5237>:
            CP = &R->child[1];
            D.6438 = *CP;
            if (D.6438 != 0B) goto <D.5236>; else goto <D.6439>;
            <D.6439>:
            CP = &R->child[0];
            D.6438 = *CP;
            if (D.6438 != 0B) goto <D.5236>; else goto <D.5238>;
            <D.5238>:
            D.6407 = m->least_addr;
            D.6440 = D.6407 <= RP;
            D.6441 = (long int) D.6440;
            D.6442 = __builtin_expect (D.6441, 1);
            if (D.6442 != 0) goto <D.6443>; else goto <D.6444>;
            <D.6443>:
            *RP = 0B;
            goto <D.6445>;
            <D.6444>:
            abort ();
            <D.6445>:
          }
          <D.6436>:
        }
        <D.6434>:
        if (XP != 0B) goto <D.6446>; else goto <D.6447>;
        <D.6446>:
        {
          struct malloc_tree_chunk * * H;

          D.6448 = TP->index;
          H = &m->treebins[D.6448];
          D.6449 = *H;
          if (D.6449 == TP) goto <D.6450>; else goto <D.6451>;
          <D.6450>:
          *H = R;
          D.6449 = *H;
          if (D.6449 == 0B) goto <D.6452>; else goto <D.6453>;
          <D.6452>:
          D.6454 = m->treemap;
          D.6448 = TP->index;
          D.6455 = (int) D.6448;
          D.6456 = 1 << D.6455;
          D.6457 = ~D.6456;
          D.6458 = D.6454 & D.6457;
          m->treemap = D.6458;
          <D.6453>:
          goto <D.6459>;
          <D.6451>:
          D.6407 = m->least_addr;
          D.6460 = D.6407 <= XP;
          D.6461 = (long int) D.6460;
          D.6462 = __builtin_expect (D.6461, 1);
          if (D.6462 != 0) goto <D.6463>; else goto <D.6464>;
          <D.6463>:
          D.6465 = XP->child[0];
          if (D.6465 == TP) goto <D.6466>; else goto <D.6467>;
          <D.6466>:
          XP->child[0] = R;
          goto <D.6468>;
          <D.6467>:
          XP->child[1] = R;
          <D.6468>:
          goto <D.6469>;
          <D.6464>:
          abort ();
          <D.6469>:
          <D.6459>:
          if (R != 0B) goto <D.6470>; else goto <D.6471>;
          <D.6470>:
          D.6407 = m->least_addr;
          D.6472 = D.6407 <= R;
          D.6473 = (long int) D.6472;
          D.6474 = __builtin_expect (D.6473, 1);
          if (D.6474 != 0) goto <D.6475>; else goto <D.6476>;
          <D.6475>:
          {
            struct malloc_tree_chunk * C0;
            struct malloc_tree_chunk * C1;

            R->parent = XP;
            C0 = TP->child[0];
            if (C0 != 0B) goto <D.6477>; else goto <D.6478>;
            <D.6477>:
            D.6407 = m->least_addr;
            D.6479 = D.6407 <= C0;
            D.6480 = (long int) D.6479;
            D.6481 = __builtin_expect (D.6480, 1);
            if (D.6481 != 0) goto <D.6482>; else goto <D.6483>;
            <D.6482>:
            R->child[0] = C0;
            C0->parent = R;
            goto <D.6484>;
            <D.6483>:
            abort ();
            <D.6484>:
            <D.6478>:
            C1 = TP->child[1];
            if (C1 != 0B) goto <D.6485>; else goto <D.6486>;
            <D.6485>:
            D.6407 = m->least_addr;
            D.6487 = D.6407 <= C1;
            D.6488 = (long int) D.6487;
            D.6489 = __builtin_expect (D.6488, 1);
            if (D.6489 != 0) goto <D.6490>; else goto <D.6491>;
            <D.6490>:
            R->child[1] = C1;
            C1->parent = R;
            goto <D.6492>;
            <D.6491>:
            abort ();
            <D.6492>:
            <D.6486>:
          }
          goto <D.6493>;
          <D.6476>:
          abort ();
          <D.6493>:
          <D.6471>:
        }
        <D.6447>:
      }
    }
    <D.6424>:
    oldfirst = oldfirst + nsize;
    qsize = qsize + nsize;
  }
  <D.6383>:
  D.6380 = oldfirst->head;
  D.6494 = D.6380 & 18446744073709551614;
  oldfirst->head = D.6494;
  D.6495 = qsize | 1;
  q->head = D.6495;
  D.6496 = q + qsize;
  D.6496->prev_foot = qsize;
  D.6497 = qsize >> 3;
  if (D.6497 <= 31) goto <D.6498>; else goto <D.6499>;
  <D.6498>:
  {
    bindex_t I;
    struct malloc_chunk * B;
    struct malloc_chunk * F;

    D.6497 = qsize >> 3;
    I = (bindex_t) D.6497;
    D.6500 = I << 1;
    B = &m->smallbins[D.6500];
    F = B;
    D.6389 = m->smallmap;
    I.47 = (int) I;
    D.6502 = 1 << I.47;
    D.6503 = D.6389 & D.6502;
    if (D.6503 == 0) goto <D.6504>; else goto <D.6505>;
    <D.6504>:
    D.6389 = m->smallmap;
    I.47 = (int) I;
    D.6502 = 1 << I.47;
    D.6506 = D.6389 | D.6502;
    m->smallmap = D.6506;
    goto <D.6507>;
    <D.6505>:
    D.6508 = B->fd;
    D.6407 = m->least_addr;
    D.6509 = D.6508 >= D.6407;
    D.6510 = (long int) D.6509;
    D.6511 = __builtin_expect (D.6510, 1);
    if (D.6511 != 0) goto <D.6512>; else goto <D.6513>;
    <D.6512>:
    F = B->fd;
    goto <D.6514>;
    <D.6513>:
    abort ();
    <D.6514>:
    <D.6507>:
    B->fd = q;
    F->bk = q;
    q->fd = F;
    q->bk = B;
  }
  goto <D.6515>;
  <D.6499>:
  {
    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.6516>; else goto <D.6517>;
        <D.6516>:
        I = 0;
        goto <D.6518>;
        <D.6517>:
        if (X > 65535) goto <D.6519>; else goto <D.6520>;
        <D.6519>:
        I = 31;
        goto <D.6521>;
        <D.6520>:
        {
          unsigned int Y;
          unsigned int N;
          unsigned int K;

          Y = (unsigned int) X;
          D.6522 = Y + 4294967040;
          D.6523 = D.6522 >> 16;
          N = D.6523 & 8;
          N.48 = (int) N;
          Y = Y << N.48;
          D.6525 = Y + 4294963200;
          D.6526 = D.6525 >> 16;
          K = D.6526 & 4;
          N = N + K;
          K.49 = (int) K;
          Y = Y << K.49;
          D.6528 = Y + 4294950912;
          D.6529 = D.6528 >> 16;
          K = D.6529 & 2;
          K.50 = K;
          N = K.50 + N;
          K.49 = (int) K;
          Y = Y << K.49;
          D.6531 = Y >> 15;
          D.6532 = D.6531 - N;
          K = D.6532 + 14;
          D.6533 = K << 1;
          D.6534 = K + 7;
          D.6535 = (int) D.6534;
          D.6536 = qsize >> D.6535;
          D.6537 = (unsigned int) D.6536;
          D.6538 = D.6537 & 1;
          I = D.6533 + D.6538;
        }
        <D.6521>:
        <D.6518>:
      }
      H = &m->treebins[I];
      TP->index = I;
      TP->child[1] = 0B;
      D.6539 = TP->child[1];
      TP->child[0] = D.6539;
      D.6454 = m->treemap;
      I.51 = (int) I;
      D.6541 = 1 << I.51;
      D.6542 = D.6454 & D.6541;
      if (D.6542 == 0) goto <D.6543>; else goto <D.6544>;
      <D.6543>:
      D.6454 = m->treemap;
      I.51 = (int) I;
      D.6541 = 1 << I.51;
      D.6545 = D.6454 | D.6541;
      m->treemap = D.6545;
      *H = TP;
      TP->parent = H;
      TP->bk = TP;
      D.6546 = TP->bk;
      TP->fd = D.6546;
      goto <D.6547>;
      <D.6544>:
      {
        struct malloc_tree_chunk * T;
        size_t K;

        T = *H;
        if (I != 31) goto <D.6549>; else goto <D.6550>;
        <D.6549>:
        D.6551 = I >> 1;
        D.6552 = D.6551 + 6;
        D.6553 = (long unsigned int) D.6552;
        D.6554 = 63 - D.6553;
        iftmp.52 = (int) D.6554;
        goto <D.6555>;
        <D.6550>:
        iftmp.52 = 0;
        <D.6555>:
        K = qsize << iftmp.52;
        <D.5257>:
        D.6556 = T->head;
        D.6557 = D.6556 & 18446744073709551612;
        if (D.6557 != qsize) goto <D.6558>; else goto <D.6559>;
        <D.6558>:
        {
          struct malloc_tree_chunk * * C;

          D.6560 = K >> 63;
          C = &T->child[D.6560];
          K = K << 1;
          D.6561 = *C;
          if (D.6561 != 0B) goto <D.6562>; else goto <D.6563>;
          <D.6562>:
          T = *C;
          goto <D.6564>;
          <D.6563>:
          D.6407 = m->least_addr;
          D.6565 = D.6407 <= C;
          D.6566 = (long int) D.6565;
          D.6567 = __builtin_expect (D.6566, 1);
          if (D.6567 != 0) goto <D.6568>; else goto <D.6569>;
          <D.6568>:
          *C = TP;
          TP->parent = T;
          TP->bk = TP;
          D.6546 = TP->bk;
          TP->fd = D.6546;
          goto <D.5255>;
          <D.6569>:
          abort ();
          <D.6564>:
        }
        goto <D.6570>;
        <D.6559>:
        {
          struct malloc_tree_chunk * F;

          F = T->fd;
          D.6407 = m->least_addr;
          D.6572 = D.6407 <= T;
          D.6573 = (long int) D.6572;
          D.6574 = __builtin_expect (D.6573, 1);
          if (D.6574 != 0) goto <D.6575>; else goto <D.6571>;
          <D.6575>:
          D.6407 = m->least_addr;
          D.6576 = D.6407 <= F;
          D.6577 = (long int) D.6576;
          D.6578 = __builtin_expect (D.6577, 1);
          if (D.6578 != 0) goto <D.6579>; else goto <D.6571>;
          <D.6579>:
          F->bk = TP;
          D.6580 = F->bk;
          T->fd = D.6580;
          TP->fd = F;
          TP->bk = T;
          TP->parent = 0B;
          goto <D.5255>;
          <D.6571>:
          abort ();
        }
        <D.6570>:
        goto <D.5257>;
        <D.5255>:
      }
      <D.6547>:
    }
  }
  <D.6515>:
  <D.6379>:
  <D.6371>:
  D.6581 = p + 16;
  return D.6581;
}


add_segment (struct malloc_state * m, char * tbase, size_t tsize, flag_t mmapped)
{
  char * D.6583;
  long unsigned int D.6584;
  sizetype D.6585;
  long unsigned int iftmp.53;
  void * D.6587;
  long unsigned int D.6588;
  long unsigned int D.6589;
  long unsigned int D.6592;
  char * iftmp.54;
  char * D.6595;
  long unsigned int D.6599;
  long unsigned int D.6600;
  size_t * D.6601;
  long int csp.55;
  long int old_top.56;
  long int D.6607;
  long unsigned int D.6608;
  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;
  int I.57;
  unsigned int D.6618;
  unsigned int D.6619;
  unsigned int D.6622;
  struct malloc_chunk * D.6624;
  char * D.6625;
  _Bool D.6626;
  long int D.6627;
  long int D.6628;
  unsigned int D.6639;
  unsigned int D.6640;
  int N.58;
  unsigned int D.6642;
  unsigned int D.6643;
  int K.59;
  unsigned int D.6645;
  unsigned int D.6646;
  unsigned int K.60;
  unsigned int D.6648;
  unsigned int D.6649;
  unsigned int D.6650;
  unsigned int D.6651;
  int D.6652;
  long unsigned int D.6653;
  unsigned int D.6654;
  unsigned int D.6655;
  struct malloc_tree_chunk * D.6656;
  unsigned int D.6657;
  int I.61;
  unsigned int D.6659;
  unsigned int D.6660;
  unsigned int D.6663;
  struct malloc_tree_chunk * D.6664;
  int iftmp.62;
  unsigned int D.6669;
  unsigned int D.6670;
  long unsigned int D.6671;
  long unsigned int D.6672;
  long unsigned int D.6674;
  long unsigned int D.6675;
  long unsigned int D.6678;
  struct malloc_tree_chunk * D.6679;
  _Bool D.6683;
  long int D.6684;
  long int D.6685;
  _Bool D.6690;
  long int D.6691;
  long int D.6692;
  _Bool D.6694;
  long int D.6695;
  long int D.6696;
  struct malloc_tree_chunk * D.6698;
  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.6583 = oldsp->base;
  D.6584 = oldsp->size;
  old_end = D.6583 + D.6584;
  ssize = 40;
  D.6585 = 18446744073709551577 - ssize;
  rawsp = old_end + D.6585;
  D.6587 = rawsp + 16;
  D.6588 = (long unsigned int) D.6587;
  D.6589 = D.6588 & 7;
  if (D.6589 != 0) goto <D.6590>; else goto <D.6591>;
  <D.6590>:
  D.6587 = rawsp + 16;
  D.6588 = (long unsigned int) D.6587;
  D.6592 = -D.6588;
  iftmp.53 = D.6592 & 7;
  goto <D.6593>;
  <D.6591>:
  iftmp.53 = 0;
  <D.6593>:
  offset = iftmp.53;
  asp = rawsp + offset;
  D.6595 = old_top + 32;
  if (D.6595 > asp) goto <D.6596>; else goto <D.6597>;
  <D.6596>:
  iftmp.54 = old_top;
  goto <D.6598>;
  <D.6597>:
  iftmp.54 = asp;
  <D.6598>:
  csp = iftmp.54;
  sp = csp;
  ss = sp + 16;
  tnext = sp + ssize;
  p = tnext;
  nfences = 0;
  D.6599 = tsize + 18446744073709551544;
  init_top (m, tbase, D.6599);
  D.6600 = ssize | 3;
  sp->head = D.6600;
  *ss = m->seg;
  m->seg.base = tbase;
  m->seg.size = tsize;
  m->seg.sflags = mmapped;
  m->seg.next = ss;
  <D.5279>:
  {
    struct malloc_chunk * nextp;

    nextp = p + 8;
    p->head = 11;
    nfences = nfences + 1;
    D.6601 = &nextp->head;
    if (D.6601 < old_end) goto <D.6602>; else goto <D.5278>;
    <D.6602>:
    p = nextp;
  }
  goto <D.5279>;
  <D.5278>:
  if (csp != old_top) goto <D.6603>; else goto <D.6604>;
  <D.6603>:
  {
    struct malloc_chunk * q;
    size_t psize;
    struct malloc_chunk * tn;

    q = old_top;
    csp.55 = (long int) csp;
    old_top.56 = (long int) old_top;
    D.6607 = csp.55 - old_top.56;
    psize = (size_t) D.6607;
    tn = q + psize;
    D.6608 = tn->head;
    D.6609 = D.6608 & 18446744073709551614;
    tn->head = D.6609;
    D.6610 = psize | 1;
    q->head = D.6610;
    D.6611 = q + psize;
    D.6611->prev_foot = psize;
    D.6612 = psize >> 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 = psize >> 3;
      I = (bindex_t) D.6612;
      D.6615 = I << 1;
      B = &m->smallbins[D.6615];
      F = B;
      D.6616 = m->smallmap;
      I.57 = (int) I;
      D.6618 = 1 << I.57;
      D.6619 = D.6616 & D.6618;
      if (D.6619 == 0) goto <D.6620>; else goto <D.6621>;
      <D.6620>:
      D.6616 = m->smallmap;
      I.57 = (int) I;
      D.6618 = 1 << I.57;
      D.6622 = D.6616 | D.6618;
      m->smallmap = D.6622;
      goto <D.6623>;
      <D.6621>:
      D.6624 = B->fd;
      D.6625 = m->least_addr;
      D.6626 = D.6624 >= D.6625;
      D.6627 = (long int) D.6626;
      D.6628 = __builtin_expect (D.6627, 1);
      if (D.6628 != 0) goto <D.6629>; else goto <D.6630>;
      <D.6629>:
      F = B->fd;
      goto <D.6631>;
      <D.6630>:
      abort ();
      <D.6631>:
      <D.6623>:
      B->fd = q;
      F->bk = q;
      q->fd = F;
      q->bk = B;
    }
    goto <D.6632>;
    <D.6614>:
    {
      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.6633>; else goto <D.6634>;
          <D.6633>:
          I = 0;
          goto <D.6635>;
          <D.6634>:
          if (X > 65535) goto <D.6636>; else goto <D.6637>;
          <D.6636>:
          I = 31;
          goto <D.6638>;
          <D.6637>:
          {
            unsigned int Y;
            unsigned int N;
            unsigned int K;

            Y = (unsigned int) X;
            D.6639 = Y + 4294967040;
            D.6640 = D.6639 >> 16;
            N = D.6640 & 8;
            N.58 = (int) N;
            Y = Y << N.58;
            D.6642 = Y + 4294963200;
            D.6643 = D.6642 >> 16;
            K = D.6643 & 4;
            N = N + K;
            K.59 = (int) K;
            Y = Y << K.59;
            D.6645 = Y + 4294950912;
            D.6646 = D.6645 >> 16;
            K = D.6646 & 2;
            K.60 = K;
            N = K.60 + N;
            K.59 = (int) K;
            Y = Y << K.59;
            D.6648 = Y >> 15;
            D.6649 = D.6648 - N;
            K = D.6649 + 14;
            D.6650 = K << 1;
            D.6651 = K + 7;
            D.6652 = (int) D.6651;
            D.6653 = psize >> D.6652;
            D.6654 = (unsigned int) D.6653;
            D.6655 = D.6654 & 1;
            I = D.6650 + D.6655;
          }
          <D.6638>:
          <D.6635>:
        }
        H = &m->treebins[I];
        TP->index = I;
        TP->child[1] = 0B;
        D.6656 = TP->child[1];
        TP->child[0] = D.6656;
        D.6657 = m->treemap;
        I.61 = (int) I;
        D.6659 = 1 << I.61;
        D.6660 = D.6657 & D.6659;
        if (D.6660 == 0) goto <D.6661>; else goto <D.6662>;
        <D.6661>:
        D.6657 = m->treemap;
        I.61 = (int) I;
        D.6659 = 1 << I.61;
        D.6663 = D.6657 | D.6659;
        m->treemap = D.6663;
        *H = TP;
        TP->parent = H;
        TP->bk = TP;
        D.6664 = TP->bk;
        TP->fd = D.6664;
        goto <D.6665>;
        <D.6662>:
        {
          struct malloc_tree_chunk * T;
          size_t K;

          T = *H;
          if (I != 31) goto <D.6667>; else goto <D.6668>;
          <D.6667>:
          D.6669 = I >> 1;
          D.6670 = D.6669 + 6;
          D.6671 = (long unsigned int) D.6670;
          D.6672 = 63 - D.6671;
          iftmp.62 = (int) D.6672;
          goto <D.6673>;
          <D.6668>:
          iftmp.62 = 0;
          <D.6673>:
          K = psize << iftmp.62;
          <D.5298>:
          D.6674 = T->head;
          D.6675 = D.6674 & 18446744073709551612;
          if (D.6675 != psize) goto <D.6676>; else goto <D.6677>;
          <D.6676>:
          {
            struct malloc_tree_chunk * * C;

            D.6678 = K >> 63;
            C = &T->child[D.6678];
            K = K << 1;
            D.6679 = *C;
            if (D.6679 != 0B) goto <D.6680>; else goto <D.6681>;
            <D.6680>:
            T = *C;
            goto <D.6682>;
            <D.6681>:
            D.6625 = m->least_addr;
            D.6683 = D.6625 <= C;
            D.6684 = (long int) D.6683;
            D.6685 = __builtin_expect (D.6684, 1);
            if (D.6685 != 0) goto <D.6686>; else goto <D.6687>;
            <D.6686>:
            *C = TP;
            TP->parent = T;
            TP->bk = TP;
            D.6664 = TP->bk;
            TP->fd = D.6664;
            goto <D.5296>;
            <D.6687>:
            abort ();
            <D.6682>:
          }
          goto <D.6688>;
          <D.6677>:
          {
            struct malloc_tree_chunk * F;

            F = T->fd;
            D.6625 = m->least_addr;
            D.6690 = D.6625 <= T;
            D.6691 = (long int) D.6690;
            D.6692 = __builtin_expect (D.6691, 1);
            if (D.6692 != 0) goto <D.6693>; else goto <D.6689>;
            <D.6693>:
            D.6625 = m->least_addr;
            D.6694 = D.6625 <= F;
            D.6695 = (long int) D.6694;
            D.6696 = __builtin_expect (D.6695, 1);
            if (D.6696 != 0) goto <D.6697>; else goto <D.6689>;
            <D.6697>:
            F->bk = TP;
            D.6698 = F->bk;
            T->fd = D.6698;
            TP->fd = F;
            TP->bk = T;
            TP->parent = 0B;
            goto <D.5296>;
            <D.6689>:
            abort ();
          }
          <D.6688>:
          goto <D.5298>;
          <D.5296>:
        }
        <D.6665>:
      }
    }
    <D.6632>:
  }
  <D.6604>:
}


segment_holding (struct malloc_state * m, char * addr)
{
  char * D.6699;
  long unsigned int D.6702;
  char * D.6703;
  struct malloc_segment * D.6706;
  struct malloc_segment * sp;

  sp = &m->seg;
  <D.5179>:
  D.6699 = sp->base;
  if (D.6699 <= addr) goto <D.6700>; else goto <D.6701>;
  <D.6700>:
  D.6699 = sp->base;
  D.6702 = sp->size;
  D.6703 = D.6699 + D.6702;
  if (D.6703 > addr) goto <D.6704>; else goto <D.6705>;
  <D.6704>:
  D.6706 = sp;
  return D.6706;
  <D.6705>:
  <D.6701>:
  sp = sp->next;
  if (sp == 0B) goto <D.6707>; else goto <D.6708>;
  <D.6707>:
  D.6706 = 0B;
  return D.6706;
  <D.6708>:
  goto <D.5179>;
}


dlfree (void * mem)
{
  long unsigned int D.6716;
  int D.6718;
  unsigned int D.6719;
  unsigned int D.6720;
  int D.6721;
  char * D.6722;
  _Bool D.6723;
  long int D.6724;
  long int D.6725;
  long unsigned int D.6728;
  long unsigned int D.6729;
  _Bool D.6730;
  long int D.6731;
  long int D.6732;
  long unsigned int D.6735;
  long unsigned int D.6738;
  long unsigned int D.6741;
  sizetype D.6742;
  void * D.6743;
  int D.6744;
  long unsigned int D.6747;
  long unsigned int D.6748;
  _Bool D.6749;
  long int D.6750;
  long int D.6751;
  struct malloc_chunk * D.6753;
  long unsigned int D.6756;
  unsigned int D.6761;
  int I.63;
  unsigned int D.6763;
  unsigned int D.6764;
  unsigned int D.6765;
  int iftmp.64;
  unsigned int D.6773;
  struct malloc_chunk * * D.6774;
  _Bool D.6775;
  long int D.6776;
  long int D.6777;
  _Bool D.6779;
  long int D.6780;
  long int D.6781;
  int iftmp.65;
  _Bool D.6787;
  long int D.6788;
  long int D.6789;
  _Bool D.6791;
  long int D.6792;
  long int D.6793;
  struct malloc_tree_chunk * D.6796;
  _Bool D.6799;
  long int D.6800;
  long int D.6801;
  struct malloc_tree_chunk * D.6809;
  _Bool D.6811;
  long int D.6812;
  long int D.6813;
  unsigned int D.6819;
  struct malloc_tree_chunk * D.6820;
  unsigned int D.6825;
  int D.6826;
  unsigned int D.6827;
  unsigned int D.6828;
  unsigned int D.6829;
  _Bool D.6831;
  long int D.6832;
  long int D.6833;
  struct malloc_tree_chunk * D.6836;
  _Bool D.6843;
  long int D.6844;
  long int D.6845;
  _Bool D.6850;
  long int D.6851;
  long int D.6852;
  _Bool D.6858;
  long int D.6859;
  long int D.6860;
  long unsigned int D.6866;
  long unsigned int D.6867;
  long unsigned int D.6870;
  long unsigned int D.6871;
  struct malloc_chunk * D.6872;
  _Bool D.6873;
  long int D.6874;
  long int D.6875;
  long unsigned int D.6878;
  _Bool D.6879;
  long int D.6880;
  long int D.6881;
  long unsigned int D.6884;
  struct malloc_chunk * D.6887;
  long unsigned int D.6890;
  long unsigned int D.6891;
  long unsigned int D.6892;
  long unsigned int D.6895;
  long unsigned int D.6900;
  long unsigned int D.6901;
  long unsigned int D.6902;
  struct malloc_chunk * D.6903;
  long unsigned int D.6904;
  int I.66;
  unsigned int D.6910;
  unsigned int D.6911;
  unsigned int D.6912;
  int iftmp.67;
  unsigned int D.6920;
  struct malloc_chunk * * D.6921;
  _Bool D.6922;
  long int D.6923;
  long int D.6924;
  _Bool D.6926;
  long int D.6927;
  long int D.6928;
  int iftmp.68;
  _Bool D.6934;
  long int D.6935;
  long int D.6936;
  _Bool D.6938;
  long int D.6939;
  long int D.6940;
  struct malloc_tree_chunk * D.6943;
  _Bool D.6946;
  long int D.6947;
  long int D.6948;
  struct malloc_tree_chunk * D.6956;
  _Bool D.6958;
  long int D.6959;
  long int D.6960;
  unsigned int D.6966;
  struct malloc_tree_chunk * D.6967;
  int D.6972;
  unsigned int D.6973;
  unsigned int D.6974;
  unsigned int D.6975;
  _Bool D.6977;
  long int D.6978;
  long int D.6979;
  struct malloc_tree_chunk * D.6982;
  _Bool D.6989;
  long int D.6990;
  long int D.6991;
  _Bool D.6996;
  long int D.6997;
  long int D.6998;
  _Bool D.7004;
  long int D.7005;
  long int D.7006;
  long unsigned int D.7014;
  unsigned int D.7017;
  int I.69;
  unsigned int D.7019;
  unsigned int D.7020;
  unsigned int D.7023;
  struct malloc_chunk * D.7025;
  _Bool D.7026;
  long int D.7027;
  long int D.7028;
  unsigned int D.7039;
  unsigned int D.7040;
  int N.70;
  unsigned int D.7042;
  unsigned int D.7043;
  int K.71;
  unsigned int D.7045;
  unsigned int D.7046;
  unsigned int K.72;
  unsigned int D.7048;
  unsigned int D.7049;
  unsigned int D.7050;
  unsigned int D.7051;
  int D.7052;
  long unsigned int D.7053;
  unsigned int D.7054;
  unsigned int D.7055;
  struct malloc_tree_chunk * D.7056;
  int I.73;
  unsigned int D.7058;
  unsigned int D.7059;
  unsigned int D.7062;
  struct malloc_tree_chunk * D.7063;
  int iftmp.74;
  unsigned int D.7068;
  unsigned int D.7069;
  long unsigned int D.7070;
  long unsigned int D.7071;
  long unsigned int D.7073;
  long unsigned int D.7074;
  long unsigned int D.7077;
  struct malloc_tree_chunk * D.7078;
  _Bool D.7082;
  long int D.7083;
  long int D.7084;
  _Bool D.7089;
  long int D.7090;
  long int D.7091;
  _Bool D.7093;
  long int D.7094;
  long int D.7095;
  struct malloc_tree_chunk * D.7097;
  void postaction = <<< error >>>;
  void erroraction = <<< error >>>;

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

    p = mem + 18446744073709551600;
    D.6716 = mparams.page_size;
    if (D.6716 != 0) goto <D.6712>; else goto <D.6717>;
    <D.6717>:
    D.6718 = init_mparams ();
    if (D.6718 == 0) goto <D.6712>; else goto <D.6713>;
    <D.6712>:
    D.6719 = _gm_.mflags;
    D.6720 = D.6719 & 2;
    if (D.6720 == 0) goto <D.6714>; else goto <D.6713>;
    <D.6713>:
    D.6721 = pthread_mutex_lock (&_gm_.mutex);
    if (D.6721 == 0) goto <D.6714>; else goto <D.6715>;
    <D.6714>:
    D.6722 = _gm_.least_addr;
    D.6723 = D.6722 <= p;
    D.6724 = (long int) D.6723;
    D.6725 = __builtin_expect (D.6724, 1);
    if (D.6725 != 0) goto <D.6726>; else goto <D.6727>;
    <D.6726>:
    D.6728 = p->head;
    D.6729 = D.6728 & 2;
    D.6730 = D.6729 != 0;
    D.6731 = (long int) D.6730;
    D.6732 = __builtin_expect (D.6731, 1);
    if (D.6732 != 0) goto <D.6733>; else goto <D.6734>;
    <D.6733>:
    {
      size_t psize;
      struct malloc_chunk * next;

      D.6728 = p->head;
      psize = D.6728 & 18446744073709551612;
      next = p + psize;
      D.6728 = p->head;
      D.6735 = D.6728 & 1;
      if (D.6735 == 0) goto <D.6736>; else goto <D.6737>;
      <D.6736>:
      {
        size_t prevsize;

        prevsize = p->prev_foot;
        D.6738 = prevsize & 1;
        if (D.6738 != 0) goto <D.6739>; else goto <D.6740>;
        <D.6739>:
        prevsize = prevsize & 18446744073709551614;
        D.6741 = prevsize + psize;
        psize = D.6741 + 32;
        D.6742 = -prevsize;
        D.6743 = p + D.6742;
        D.6744 = munmap (D.6743, psize);
        if (D.6744 == 0) goto <D.6745>; else goto <D.6746>;
        <D.6745>:
        D.6747 = _gm_.footprint;
        D.6748 = D.6747 - psize;
        _gm_.footprint = D.6748;
        <D.6746>:
        goto postaction;
        <D.6740>:
        {
          struct malloc_chunk * prev;

          D.6742 = -prevsize;
          prev = p + D.6742;
          psize = psize + prevsize;
          p = prev;
          D.6722 = _gm_.least_addr;
          D.6749 = D.6722 <= prev;
          D.6750 = (long int) D.6749;
          D.6751 = __builtin_expect (D.6750, 1);
          if (D.6751 != 0) goto <D.6752>; else goto erroraction;
          <D.6752>:
          D.6753 = _gm_.dv;
          if (D.6753 != p) goto <D.6754>; else goto <D.6755>;
          <D.6754>:
          D.6756 = prevsize >> 3;
          if (D.6756 <= 31) goto <D.6757>; else goto <D.6758>;
          <D.6757>:
          {
            struct malloc_chunk * F;
            struct malloc_chunk * B;
            bindex_t I;

            F = p->fd;
            B = p->bk;
            D.6756 = prevsize >> 3;
            I = (bindex_t) D.6756;
            if (F == B) goto <D.6759>; else goto <D.6760>;
            <D.6759>:
            D.6761 = _gm_.smallmap;
            I.63 = (int) I;
            D.6763 = 1 << I.63;
            D.6764 = ~D.6763;
            D.6765 = D.6761 & D.6764;
            _gm_.smallmap = D.6765;
            goto <D.6766>;
            <D.6760>:
            D.6773 = I << 1;
            D.6774 = &_gm_.smallbins[D.6773];
            D.6775 = D.6774 == F;
            D.6776 = (long int) D.6775;
            D.6777 = __builtin_expect (D.6776, 1);
            if (D.6777 != 0) goto <D.6770>; else goto <D.6778>;
            <D.6778>:
            D.6722 = _gm_.least_addr;
            D.6779 = D.6722 <= F;
            D.6780 = (long int) D.6779;
            D.6781 = __builtin_expect (D.6780, 1);
            if (D.6781 != 0) goto <D.6770>; else goto <D.6771>;
            <D.6770>:
            iftmp.64 = 1;
            goto <D.6772>;
            <D.6771>:
            iftmp.64 = 0;
            <D.6772>:
            if (iftmp.64 != 0) goto <D.6782>; else goto <D.6767>;
            <D.6782>:
            D.6773 = I << 1;
            D.6774 = &_gm_.smallbins[D.6773];
            D.6787 = D.6774 == B;
            D.6788 = (long int) D.6787;
            D.6789 = __builtin_expect (D.6788, 1);
            if (D.6789 != 0) goto <D.6784>; else goto <D.6790>;
            <D.6790>:
            D.6722 = _gm_.least_addr;
            D.6791 = D.6722 <= B;
            D.6792 = (long int) D.6791;
            D.6793 = __builtin_expect (D.6792, 1);
            if (D.6793 != 0) goto <D.6784>; else goto <D.6785>;
            <D.6784>:
            iftmp.65 = 1;
            goto <D.6786>;
            <D.6785>:
            iftmp.65 = 0;
            <D.6786>:
            if (iftmp.65 != 0) goto <D.6794>; else goto <D.6767>;
            <D.6794>:
            F->bk = B;
            B->fd = F;
            goto <D.6768>;
            <D.6767>:
            abort ();
            <D.6768>:
            <D.6766>:
          }
          goto <D.6795>;
          <D.6758>:
          {
            struct malloc_tree_chunk * TP;

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

              XP = TP->parent;
              D.6796 = TP->bk;
              if (D.6796 != TP) goto <D.6797>; else goto <D.6798>;
              <D.6797>:
              {
                struct malloc_tree_chunk * F;

                F = TP->fd;
                R = TP->bk;
                D.6722 = _gm_.least_addr;
                D.6799 = D.6722 <= F;
                D.6800 = (long int) D.6799;
                D.6801 = __builtin_expect (D.6800, 1);
                if (D.6801 != 0) goto <D.6802>; else goto <D.6803>;
                <D.6802>:
                F->bk = R;
                R->fd = F;
                goto <D.6804>;
                <D.6803>:
                abort ();
                <D.6804>:
              }
              goto <D.6805>;
              <D.6798>:
              {
                struct malloc_tree_chunk * * RP;

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

                  goto <D.5547>;
                  <D.5546>:
                  RP = CP;
                  R = *RP;
                  <D.5547>:
                  CP = &R->child[1];
                  D.6809 = *CP;
                  if (D.6809 != 0B) goto <D.5546>; else goto <D.6810>;
                  <D.6810>:
                  CP = &R->child[0];
                  D.6809 = *CP;
                  if (D.6809 != 0B) goto <D.5546>; else goto <D.5548>;
                  <D.5548>:
                  D.6722 = _gm_.least_addr;
                  D.6811 = D.6722 <= RP;
                  D.6812 = (long int) D.6811;
                  D.6813 = __builtin_expect (D.6812, 1);
                  if (D.6813 != 0) goto <D.6814>; else goto <D.6815>;
                  <D.6814>:
                  *RP = 0B;
                  goto <D.6816>;
                  <D.6815>:
                  abort ();
                  <D.6816>:
                }
                <D.6807>:
              }
              <D.6805>:
              if (XP != 0B) goto <D.6817>; else goto <D.6818>;
              <D.6817>:
              {
                struct malloc_tree_chunk * * H;

                D.6819 = TP->index;
                H = &_gm_.treebins[D.6819];
                D.6820 = *H;
                if (D.6820 == TP) goto <D.6821>; else goto <D.6822>;
                <D.6821>:
                *H = R;
                D.6820 = *H;
                if (D.6820 == 0B) goto <D.6823>; else goto <D.6824>;
                <D.6823>:
                D.6825 = _gm_.treemap;
                D.6819 = TP->index;
                D.6826 = (int) D.6819;
                D.6827 = 1 << D.6826;
                D.6828 = ~D.6827;
                D.6829 = D.6825 & D.6828;
                _gm_.treemap = D.6829;
                <D.6824>:
                goto <D.6830>;
                <D.6822>:
                D.6722 = _gm_.least_addr;
                D.6831 = D.6722 <= XP;
                D.6832 = (long int) D.6831;
                D.6833 = __builtin_expect (D.6832, 1);
                if (D.6833 != 0) goto <D.6834>; else goto <D.6835>;
                <D.6834>:
                D.6836 = XP->child[0];
                if (D.6836 == TP) goto <D.6837>; else goto <D.6838>;
                <D.6837>:
                XP->child[0] = R;
                goto <D.6839>;
                <D.6838>:
                XP->child[1] = R;
                <D.6839>:
                goto <D.6840>;
                <D.6835>:
                abort ();
                <D.6840>:
                <D.6830>:
                if (R != 0B) goto <D.6841>; else goto <D.6842>;
                <D.6841>:
                D.6722 = _gm_.least_addr;
                D.6843 = D.6722 <= R;
                D.6844 = (long int) D.6843;
                D.6845 = __builtin_expect (D.6844, 1);
                if (D.6845 != 0) goto <D.6846>; else goto <D.6847>;
                <D.6846>:
                {
                  struct malloc_tree_chunk * C0;
                  struct malloc_tree_chunk * C1;

                  R->parent = XP;
                  C0 = TP->child[0];
                  if (C0 != 0B) goto <D.6848>; else goto <D.6849>;
                  <D.6848>:
                  D.6722 = _gm_.least_addr;
                  D.6850 = D.6722 <= C0;
                  D.6851 = (long int) D.6850;
                  D.6852 = __builtin_expect (D.6851, 1);
                  if (D.6852 != 0) goto <D.6853>; else goto <D.6854>;
                  <D.6853>:
                  R->child[0] = C0;
                  C0->parent = R;
                  goto <D.6855>;
                  <D.6854>:
                  abort ();
                  <D.6855>:
                  <D.6849>:
                  C1 = TP->child[1];
                  if (C1 != 0B) goto <D.6856>; else goto <D.6857>;
                  <D.6856>:
                  D.6722 = _gm_.least_addr;
                  D.6858 = D.6722 <= C1;
                  D.6859 = (long int) D.6858;
                  D.6860 = __builtin_expect (D.6859, 1);
                  if (D.6860 != 0) goto <D.6861>; else goto <D.6862>;
                  <D.6861>:
                  R->child[1] = C1;
                  C1->parent = R;
                  goto <D.6863>;
                  <D.6862>:
                  abort ();
                  <D.6863>:
                  <D.6857>:
                }
                goto <D.6864>;
                <D.6847>:
                abort ();
                <D.6864>:
                <D.6842>:
              }
              <D.6818>:
            }
          }
          <D.6795>:
          goto <D.6865>;
          <D.6755>:
          D.6866 = next->head;
          D.6867 = D.6866 & 3;
          if (D.6867 == 3) goto <D.6868>; else goto <D.6869>;
          <D.6868>:
          _gm_.dvsize = psize;
          D.6866 = next->head;
          D.6870 = D.6866 & 18446744073709551614;
          next->head = D.6870;
          D.6871 = psize | 1;
          p->head = D.6871;
          D.6872 = p + psize;
          D.6872->prev_foot = psize;
          goto postaction;
          <D.6869>:
          <D.6865>:
        }
      }
      <D.6737>:
      D.6873 = p < next;
      D.6874 = (long int) D.6873;
      D.6875 = __builtin_expect (D.6874, 1);
      if (D.6875 != 0) goto <D.6876>; else goto <D.6877>;
      <D.6876>:
      D.6866 = next->head;
      D.6878 = D.6866 & 1;
      D.6879 = D.6878 != 0;
      D.6880 = (long int) D.6879;
      D.6881 = __builtin_expect (D.6880, 1);
      if (D.6881 != 0) goto <D.6882>; else goto <D.6883>;
      <D.6882>:
      D.6866 = next->head;
      D.6884 = D.6866 & 2;
      if (D.6884 == 0) goto <D.6885>; else goto <D.6886>;
      <D.6885>:
      D.6887 = _gm_.top;
      if (D.6887 == next) goto <D.6888>; else goto <D.6889>;
      <D.6888>:
      {
        size_t tsize;

        D.6890 = _gm_.topsize;
        D.6891 = D.6890 + psize;
        _gm_.topsize = D.6891;
        tsize = _gm_.topsize;
        _gm_.top = p;
        D.6892 = tsize | 1;
        p->head = D.6892;
        D.6753 = _gm_.dv;
        if (D.6753 == p) goto <D.6893>; else goto <D.6894>;
        <D.6893>:
        _gm_.dv = 0B;
        _gm_.dvsize = 0;
        <D.6894>:
        D.6895 = _gm_.trim_check;
        if (D.6895 < tsize) goto <D.6896>; else goto <D.6897>;
        <D.6896>:
        sys_trim (&_gm_, 0);
        <D.6897>:
        goto postaction;
      }
      <D.6889>:
      D.6753 = _gm_.dv;
      if (D.6753 == next) goto <D.6898>; else goto <D.6899>;
      <D.6898>:
      {
        size_t dsize;

        D.6900 = _gm_.dvsize;
        D.6901 = D.6900 + psize;
        _gm_.dvsize = D.6901;
        dsize = _gm_.dvsize;
        _gm_.dv = p;
        D.6902 = dsize | 1;
        p->head = D.6902;
        D.6903 = p + dsize;
        D.6903->prev_foot = dsize;
        goto postaction;
      }
      <D.6899>:
      {
        size_t nsize;

        D.6866 = next->head;
        nsize = D.6866 & 18446744073709551612;
        psize = psize + nsize;
        D.6904 = nsize >> 3;
        if (D.6904 <= 31) goto <D.6905>; else goto <D.6906>;
        <D.6905>:
        {
          struct malloc_chunk * F;
          struct malloc_chunk * B;
          bindex_t I;

          F = next->fd;
          B = next->bk;
          D.6904 = nsize >> 3;
          I = (bindex_t) D.6904;
          if (F == B) goto <D.6907>; else goto <D.6908>;
          <D.6907>:
          D.6761 = _gm_.smallmap;
          I.66 = (int) I;
          D.6910 = 1 << I.66;
          D.6911 = ~D.6910;
          D.6912 = D.6761 & D.6911;
          _gm_.smallmap = D.6912;
          goto <D.6913>;
          <D.6908>:
          D.6920 = I << 1;
          D.6921 = &_gm_.smallbins[D.6920];
          D.6922 = D.6921 == F;
          D.6923 = (long int) D.6922;
          D.6924 = __builtin_expect (D.6923, 1);
          if (D.6924 != 0) goto <D.6917>; else goto <D.6925>;
          <D.6925>:
          D.6722 = _gm_.least_addr;
          D.6926 = D.6722 <= F;
          D.6927 = (long int) D.6926;
          D.6928 = __builtin_expect (D.6927, 1);
          if (D.6928 != 0) goto <D.6917>; else goto <D.6918>;
          <D.6917>:
          iftmp.67 = 1;
          goto <D.6919>;
          <D.6918>:
          iftmp.67 = 0;
          <D.6919>:
          if (iftmp.67 != 0) goto <D.6929>; else goto <D.6914>;
          <D.6929>:
          D.6920 = I << 1;
          D.6921 = &_gm_.smallbins[D.6920];
          D.6934 = D.6921 == B;
          D.6935 = (long int) D.6934;
          D.6936 = __builtin_expect (D.6935, 1);
          if (D.6936 != 0) goto <D.6931>; else goto <D.6937>;
          <D.6937>:
          D.6722 = _gm_.least_addr;
          D.6938 = D.6722 <= B;
          D.6939 = (long int) D.6938;
          D.6940 = __builtin_expect (D.6939, 1);
          if (D.6940 != 0) goto <D.6931>; else goto <D.6932>;
          <D.6931>:
          iftmp.68 = 1;
          goto <D.6933>;
          <D.6932>:
          iftmp.68 = 0;
          <D.6933>:
          if (iftmp.68 != 0) goto <D.6941>; else goto <D.6914>;
          <D.6941>:
          F->bk = B;
          B->fd = F;
          goto <D.6915>;
          <D.6914>:
          abort ();
          <D.6915>:
          <D.6913>:
        }
        goto <D.6942>;
        <D.6906>:
        {
          struct malloc_tree_chunk * TP;

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

            XP = TP->parent;
            D.6943 = TP->bk;
            if (D.6943 != TP) goto <D.6944>; else goto <D.6945>;
            <D.6944>:
            {
              struct malloc_tree_chunk * F;

              F = TP->fd;
              R = TP->bk;
              D.6722 = _gm_.least_addr;
              D.6946 = D.6722 <= F;
              D.6947 = (long int) D.6946;
              D.6948 = __builtin_expect (D.6947, 1);
              if (D.6948 != 0) goto <D.6949>; else goto <D.6950>;
              <D.6949>:
              F->bk = R;
              R->fd = F;
              goto <D.6951>;
              <D.6950>:
              abort ();
              <D.6951>:
            }
            goto <D.6952>;
            <D.6945>:
            {
              struct malloc_tree_chunk * * RP;

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

                goto <D.5566>;
                <D.5565>:
                RP = CP;
                R = *RP;
                <D.5566>:
                CP = &R->child[1];
                D.6956 = *CP;
                if (D.6956 != 0B) goto <D.5565>; else goto <D.6957>;
                <D.6957>:
                CP = &R->child[0];
                D.6956 = *CP;
                if (D.6956 != 0B) goto <D.5565>; else goto <D.5567>;
                <D.5567>:
                D.6722 = _gm_.least_addr;
                D.6958 = D.6722 <= RP;
                D.6959 = (long int) D.6958;
                D.6960 = __builtin_expect (D.6959, 1);
                if (D.6960 != 0) goto <D.6961>; else goto <D.6962>;
                <D.6961>:
                *RP = 0B;
                goto <D.6963>;
                <D.6962>:
                abort ();
                <D.6963>:
              }
              <D.6954>:
            }
            <D.6952>:
            if (XP != 0B) goto <D.6964>; else goto <D.6965>;
            <D.6964>:
            {
              struct malloc_tree_chunk * * H;

              D.6966 = TP->index;
              H = &_gm_.treebins[D.6966];
              D.6967 = *H;
              if (D.6967 == TP) goto <D.6968>; else goto <D.6969>;
              <D.6968>:
              *H = R;
              D.6967 = *H;
              if (D.6967 == 0B) goto <D.6970>; else goto <D.6971>;
              <D.6970>:
              D.6825 = _gm_.treemap;
              D.6966 = TP->index;
              D.6972 = (int) D.6966;
              D.6973 = 1 << D.6972;
              D.6974 = ~D.6973;
              D.6975 = D.6825 & D.6974;
              _gm_.treemap = D.6975;
              <D.6971>:
              goto <D.6976>;
              <D.6969>:
              D.6722 = _gm_.least_addr;
              D.6977 = D.6722 <= XP;
              D.6978 = (long int) D.6977;
              D.6979 = __builtin_expect (D.6978, 1);
              if (D.6979 != 0) goto <D.6980>; else goto <D.6981>;
              <D.6980>:
              D.6982 = XP->child[0];
              if (D.6982 == TP) goto <D.6983>; else goto <D.6984>;
              <D.6983>:
              XP->child[0] = R;
              goto <D.6985>;
              <D.6984>:
              XP->child[1] = R;
              <D.6985>:
              goto <D.6986>;
              <D.6981>:
              abort ();
              <D.6986>:
              <D.6976>:
              if (R != 0B) goto <D.6987>; else goto <D.6988>;
              <D.6987>:
              D.6722 = _gm_.least_addr;
              D.6989 = D.6722 <= R;
              D.6990 = (long int) D.6989;
              D.6991 = __builtin_expect (D.6990, 1);
              if (D.6991 != 0) goto <D.6992>; else goto <D.6993>;
              <D.6992>:
              {
                struct malloc_tree_chunk * C0;
                struct malloc_tree_chunk * C1;

                R->parent = XP;
                C0 = TP->child[0];
                if (C0 != 0B) goto <D.6994>; else goto <D.6995>;
                <D.6994>:
                D.6722 = _gm_.least_addr;
                D.6996 = D.6722 <= C0;
                D.6997 = (long int) D.6996;
                D.6998 = __builtin_expect (D.6997, 1);
                if (D.6998 != 0) goto <D.6999>; else goto <D.7000>;
                <D.6999>:
                R->child[0] = C0;
                C0->parent = R;
                goto <D.7001>;
                <D.7000>:
                abort ();
                <D.7001>:
                <D.6995>:
                C1 = TP->child[1];
                if (C1 != 0B) goto <D.7002>; else goto <D.7003>;
                <D.7002>:
                D.6722 = _gm_.least_addr;
                D.7004 = D.6722 <= C1;
                D.7005 = (long int) D.7004;
                D.7006 = __builtin_expect (D.7005, 1);
                if (D.7006 != 0) goto <D.7007>; else goto <D.7008>;
                <D.7007>:
                R->child[1] = C1;
                C1->parent = R;
                goto <D.7009>;
                <D.7008>:
                abort ();
                <D.7009>:
                <D.7003>:
              }
              goto <D.7010>;
              <D.6993>:
              abort ();
              <D.7010>:
              <D.6988>:
            }
            <D.6965>:
          }
        }
        <D.6942>:
        D.6871 = psize | 1;
        p->head = D.6871;
        D.6872 = p + psize;
        D.6872->prev_foot = psize;
        D.6753 = _gm_.dv;
        if (D.6753 == p) goto <D.7011>; else goto <D.7012>;
        <D.7011>:
        _gm_.dvsize = psize;
        goto postaction;
        <D.7012>:
      }
      goto <D.7013>;
      <D.6886>:
      D.6866 = next->head;
      D.6870 = D.6866 & 18446744073709551614;
      next->head = D.6870;
      D.6871 = psize | 1;
      p->head = D.6871;
      D.6872 = p + psize;
      D.6872->prev_foot = psize;
      <D.7013>:
      D.7014 = psize >> 3;
      if (D.7014 <= 31) goto <D.7015>; else goto <D.7016>;
      <D.7015>:
      {
        bindex_t I;
        struct malloc_chunk * B;
        struct malloc_chunk * F;

        D.7014 = psize >> 3;
        I = (bindex_t) D.7014;
        D.7017 = I << 1;
        B = &_gm_.smallbins[D.7017];
        F = B;
        D.6761 = _gm_.smallmap;
        I.69 = (int) I;
        D.7019 = 1 << I.69;
        D.7020 = D.6761 & D.7019;
        if (D.7020 == 0) goto <D.7021>; else goto <D.7022>;
        <D.7021>:
        D.6761 = _gm_.smallmap;
        I.69 = (int) I;
        D.7019 = 1 << I.69;
        D.7023 = D.6761 | D.7019;
        _gm_.smallmap = D.7023;
        goto <D.7024>;
        <D.7022>:
        D.7025 = B->fd;
        D.6722 = _gm_.least_addr;
        D.7026 = D.7025 >= D.6722;
        D.7027 = (long int) D.7026;
        D.7028 = __builtin_expect (D.7027, 1);
        if (D.7028 != 0) goto <D.7029>; else goto <D.7030>;
        <D.7029>:
        F = B->fd;
        goto <D.7031>;
        <D.7030>:
        abort ();
        <D.7031>:
        <D.7024>:
        B->fd = p;
        F->bk = p;
        p->fd = F;
        p->bk = B;
      }
      goto <D.7032>;
      <D.7016>:
      {
        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.7033>; else goto <D.7034>;
            <D.7033>:
            I = 0;
            goto <D.7035>;
            <D.7034>:
            if (X > 65535) goto <D.7036>; else goto <D.7037>;
            <D.7036>:
            I = 31;
            goto <D.7038>;
            <D.7037>:
            {
              unsigned int Y;
              unsigned int N;
              unsigned int K;

              Y = (unsigned int) X;
              D.7039 = Y + 4294967040;
              D.7040 = D.7039 >> 16;
              N = D.7040 & 8;
              N.70 = (int) N;
              Y = Y << N.70;
              D.7042 = Y + 4294963200;
              D.7043 = D.7042 >> 16;
              K = D.7043 & 4;
              N = N + K;
              K.71 = (int) K;
              Y = Y << K.71;
              D.7045 = Y + 4294950912;
              D.7046 = D.7045 >> 16;
              K = D.7046 & 2;
              K.72 = K;
              N = K.72 + N;
              K.71 = (int) K;
              Y = Y << K.71;
              D.7048 = Y >> 15;
              D.7049 = D.7048 - N;
              K = D.7049 + 14;
              D.7050 = K << 1;
              D.7051 = K + 7;
              D.7052 = (int) D.7051;
              D.7053 = psize >> D.7052;
              D.7054 = (unsigned int) D.7053;
              D.7055 = D.7054 & 1;
              I = D.7050 + D.7055;
            }
            <D.7038>:
            <D.7035>:
          }
          H = &_gm_.treebins[I];
          TP->index = I;
          TP->child[1] = 0B;
          D.7056 = TP->child[1];
          TP->child[0] = D.7056;
          D.6825 = _gm_.treemap;
          I.73 = (int) I;
          D.7058 = 1 << I.73;
          D.7059 = D.6825 & D.7058;
          if (D.7059 == 0) goto <D.7060>; else goto <D.7061>;
          <D.7060>:
          D.6825 = _gm_.treemap;
          I.73 = (int) I;
          D.7058 = 1 << I.73;
          D.7062 = D.6825 | D.7058;
          _gm_.treemap = D.7062;
          *H = TP;
          TP->parent = H;
          TP->bk = TP;
          D.7063 = TP->bk;
          TP->fd = D.7063;
          goto <D.7064>;
          <D.7061>:
          {
            struct malloc_tree_chunk * T;
            size_t K;

            T = *H;
            if (I != 31) goto <D.7066>; else goto <D.7067>;
            <D.7066>:
            D.7068 = I >> 1;
            D.7069 = D.7068 + 6;
            D.7070 = (long unsigned int) D.7069;
            D.7071 = 63 - D.7070;
            iftmp.74 = (int) D.7071;
            goto <D.7072>;
            <D.7067>:
            iftmp.74 = 0;
            <D.7072>:
            K = psize << iftmp.74;
            <D.5586>:
            D.7073 = T->head;
            D.7074 = D.7073 & 18446744073709551612;
            if (D.7074 != psize) goto <D.7075>; else goto <D.7076>;
            <D.7075>:
            {
              struct malloc_tree_chunk * * C;

              D.7077 = K >> 63;
              C = &T->child[D.7077];
              K = K << 1;
              D.7078 = *C;
              if (D.7078 != 0B) goto <D.7079>; else goto <D.7080>;
              <D.7079>:
              T = *C;
              goto <D.7081>;
              <D.7080>:
              D.6722 = _gm_.least_addr;
              D.7082 = D.6722 <= C;
              D.7083 = (long int) D.7082;
              D.7084 = __builtin_expect (D.7083, 1);
              if (D.7084 != 0) goto <D.7085>; else goto <D.7086>;
              <D.7085>:
              *C = TP;
              TP->parent = T;
              TP->bk = TP;
              D.7063 = TP->bk;
              TP->fd = D.7063;
              goto <D.5584>;
              <D.7086>:
              abort ();
              <D.7081>:
            }
            goto <D.7087>;
            <D.7076>:
            {
              struct malloc_tree_chunk * F;

              F = T->fd;
              D.6722 = _gm_.least_addr;
              D.7089 = D.6722 <= T;
              D.7090 = (long int) D.7089;
              D.7091 = __builtin_expect (D.7090, 1);
              if (D.7091 != 0) goto <D.7092>; else goto <D.7088>;
              <D.7092>:
              D.6722 = _gm_.least_addr;
              D.7093 = D.6722 <= F;
              D.7094 = (long int) D.7093;
              D.7095 = __builtin_expect (D.7094, 1);
              if (D.7095 != 0) goto <D.7096>; else goto <D.7088>;
              <D.7096>:
              F->bk = TP;
              D.7097 = F->bk;
              T->fd = D.7097;
              TP->fd = F;
              TP->bk = T;
              TP->parent = 0B;
              goto <D.5584>;
              <D.7088>:
              abort ();
            }
            <D.7087>:
            goto <D.5586>;
            <D.5584>:
          }
          <D.7064>:
        }
      }
      <D.7032>:
      goto postaction;
      <D.6883>:
      <D.6877>:
    }
    <D.6734>:
    <D.6727>:
    erroraction:
    abort ();
    postaction:
    D.6719 = _gm_.mflags;
    D.6720 = D.6719 & 2;
    if (D.6720 != 0) goto <D.7098>; else goto <D.7099>;
    <D.7098>:
    pthread_mutex_unlock (&_gm_.mutex);
    <D.7099>:
    <D.6715>:
  }
  <D.6711>:
}


sys_trim (struct malloc_state * m, size_t pad)
{
  struct malloc_chunk * D.7102;
  long unsigned int D.7105;
  long unsigned int D.7108;
  long unsigned int D.7109;
  long unsigned int D.7110;
  long unsigned int D.7111;
  long unsigned int D.7112;
  unsigned int D.7113;
  unsigned int D.7114;
  long unsigned int D.7117;
  long unsigned int D.7118;
  long unsigned int D.7121;
  int D.7124;
  char * D.7129;
  void * D.7130;
  void * D.7132;
  int D.7133;
  char * D.7139;
  _Bool D.7142;
  _Bool D.7143;
  _Bool D.7144;
  long int old_br.75;
  long int new_br.76;
  long int D.7149;
  long unsigned int D.7152;
  long unsigned int D.7153;
  long unsigned int D.7154;
  long unsigned int D.7155;
  long unsigned int D.7158;
  int D.7161;
  _Bool D.7162;
  size_t released;

  released = 0;
  if (pad <= 18446744073709551487) goto <D.7100>; else goto <D.7101>;
  <D.7100>:
  D.7102 = m->top;
  if (D.7102 != 0B) goto <D.7103>; else goto <D.7104>;
  <D.7103>:
  pad = pad + 72;
  D.7105 = m->topsize;
  if (D.7105 > pad) goto <D.7106>; else goto <D.7107>;
  <D.7106>:
  {
    size_t unit;
    size_t extra;
    struct malloc_segment * sp;

    unit = mparams.granularity;
    D.7105 = m->topsize;
    D.7108 = D.7105 - pad;
    D.7109 = D.7108 + unit;
    D.7110 = D.7109 + 18446744073709551615;
    D.7111 = D.7110 / unit;
    D.7112 = D.7111 + 18446744073709551615;
    extra = D.7112 * unit;
    D.7102 = m->top;
    sp = segment_holding (m, D.7102);
    D.7113 = sp->sflags;
    D.7114 = D.7113 & 8;
    if (D.7114 == 0) goto <D.7115>; else goto <D.7116>;
    <D.7115>:
    D.7113 = sp->sflags;
    D.7117 = (long unsigned int) D.7113;
    D.7118 = D.7117 & 1;
    if (D.7118 != 0) goto <D.7119>; else goto <D.7120>;
    <D.7119>:
    D.7121 = sp->size;
    if (D.7121 >= extra) goto <D.7122>; else goto <D.7123>;
    <D.7122>:
    D.7124 = has_segment_link (m, sp);
    if (D.7124 == 0) goto <D.7125>; else goto <D.7126>;
    <D.7125>:
    {
      size_t newsize;

      D.7121 = sp->size;
      newsize = D.7121 - extra;
      D.7121 = sp->size;
      D.7129 = sp->base;
      D.7130 = mremap (D.7129, D.7121, newsize, 0);
      if (D.7130 != -1B) goto <D.7127>; else goto <D.7131>;
      <D.7131>:
      D.7129 = sp->base;
      D.7132 = D.7129 + newsize;
      D.7133 = munmap (D.7132, extra);
      if (D.7133 == 0) goto <D.7127>; else goto <D.7128>;
      <D.7127>:
      released = extra;
      <D.7128>:
    }
    <D.7126>:
    <D.7123>:
    goto <D.7134>;
    <D.7120>:
    if (0 != 0) goto <D.7135>; else goto <D.7136>;
    <D.7135>:
    if (extra > 9223372036854775806) goto <D.7137>; else goto <D.7138>;
    <D.7137>:
    extra = 9223372036854775808 - unit;
    <D.7138>:
    {
      char * old_br;

      old_br = -1B;
      D.7129 = sp->base;
      D.7121 = sp->size;
      D.7139 = D.7129 + D.7121;
      if (D.7139 == old_br) goto <D.7140>; else goto <D.7141>;
      <D.7140>:
      {
        char * rel_br;
        char * new_br;

        rel_br = -1B;
        new_br = -1B;
        D.7142 = rel_br != -1B;
        D.7143 = new_br < old_br;
        D.7144 = D.7142 & D.7143;
        if (D.7144 != 0) goto <D.7145>; else goto <D.7146>;
        <D.7145>:
        old_br.75 = (long int) old_br;
        new_br.76 = (long int) new_br;
        D.7149 = old_br.75 - new_br.76;
        released = (size_t) D.7149;
        <D.7146>:
      }
      <D.7141>:
    }
    <D.7136>:
    <D.7134>:
    <D.7116>:
    if (released != 0) goto <D.7150>; else goto <D.7151>;
    <D.7150>:
    D.7121 = sp->size;
    D.7152 = D.7121 - released;
    sp->size = D.7152;
    D.7153 = m->footprint;
    D.7154 = D.7153 - released;
    m->footprint = D.7154;
    D.7105 = m->topsize;
    D.7155 = D.7105 - released;
    D.7102 = m->top;
    init_top (m, D.7102, D.7155);
    <D.7151>:
  }
  <D.7107>:
  if (1 != 0) goto <D.7156>; else goto <D.7157>;
  <D.7156>:
  D.7158 = release_unused_segments (m);
  released = D.7158 + released;
  <D.7157>:
  if (released == 0) goto <D.7159>; else goto <D.7160>;
  <D.7159>:
  m->trim_check = 18446744073709551615;
  <D.7160>:
  <D.7104>:
  <D.7101>:
  D.7162 = released != 0;
  D.7161 = (int) D.7162;
  return D.7161;
}


has_segment_link (struct malloc_state * m, struct malloc_segment * ss)
{
  char * D.7164;
  long unsigned int D.7167;
  char * D.7168;
  int D.7171;
  struct malloc_segment * sp;

  sp = &m->seg;
  <D.5185>:
  D.7164 = ss->base;
  if (D.7164 <= sp) goto <D.7165>; else goto <D.7166>;
  <D.7165>:
  D.7164 = ss->base;
  D.7167 = ss->size;
  D.7168 = D.7164 + D.7167;
  if (D.7168 > sp) goto <D.7169>; else goto <D.7170>;
  <D.7169>:
  D.7171 = 1;
  return D.7171;
  <D.7170>:
  <D.7166>:
  sp = sp->next;
  if (sp == 0B) goto <D.7172>; else goto <D.7173>;
  <D.7172>:
  D.7171 = 0;
  return D.7171;
  <D.7173>:
  goto <D.5185>;
}


release_unused_segments (struct malloc_state * m)
{
  unsigned int D.7175;
  long unsigned int D.7176;
  long unsigned int D.7177;
  unsigned int D.7180;
  sizetype iftmp.77;
  void * D.7184;
  long unsigned int D.7185;
  long unsigned int D.7186;
  long unsigned int D.7189;
  long unsigned int D.7191;
  long unsigned int D.7192;
  char * D.7195;
  sizetype D.7196;
  char * D.7197;
  struct malloc_chunk * D.7200;
  struct malloc_tree_chunk * D.7204;
  char * D.7207;
  _Bool D.7208;
  long int D.7209;
  long int D.7210;
  struct malloc_tree_chunk * D.7218;
  _Bool D.7220;
  long int D.7221;
  long int D.7222;
  unsigned int D.7228;
  struct malloc_tree_chunk * D.7229;
  unsigned int D.7234;
  int D.7235;
  unsigned int D.7236;
  unsigned int D.7237;
  unsigned int D.7238;
  _Bool D.7240;
  long int D.7241;
  long int D.7242;
  struct malloc_tree_chunk * D.7245;
  _Bool D.7252;
  long int D.7253;
  long int D.7254;
  _Bool D.7259;
  long int D.7260;
  long int D.7261;
  _Bool D.7267;
  long int D.7268;
  long int D.7269;
  int D.7274;
  long unsigned int D.7277;
  long unsigned int D.7278;
  unsigned int D.7286;
  unsigned int D.7287;
  int N.78;
  unsigned int D.7289;
  unsigned int D.7290;
  int K.79;
  unsigned int D.7292;
  unsigned int D.7293;
  unsigned int K.80;
  unsigned int D.7295;
  unsigned int D.7296;
  unsigned int D.7297;
  unsigned int D.7298;
  int D.7299;
  long unsigned int D.7300;
  unsigned int D.7301;
  unsigned int D.7302;
  struct malloc_tree_chunk * D.7303;
  int I.81;
  unsigned int D.7305;
  unsigned int D.7306;
  unsigned int D.7309;
  int iftmp.82;
  unsigned int D.7314;
  unsigned int D.7315;
  long unsigned int D.7316;
  long unsigned int D.7317;
  long unsigned int D.7319;
  long unsigned int D.7320;
  long unsigned int D.7323;
  struct malloc_tree_chunk * D.7324;
  _Bool D.7328;
  long int D.7329;
  long int D.7330;
  _Bool D.7335;
  long int D.7336;
  long int D.7337;
  _Bool D.7339;
  long int D.7340;
  long int D.7341;
  struct malloc_tree_chunk * D.7343;
  size_t D.7344;
  size_t released;
  struct malloc_segment * pred;
  struct malloc_segment * sp;

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

    base = sp->base;
    size = sp->size;
    next = sp->next;
    D.7175 = sp->sflags;
    D.7176 = (long unsigned int) D.7175;
    D.7177 = D.7176 & 1;
    if (D.7177 != 0) goto <D.7178>; else goto <D.7179>;
    <D.7178>:
    D.7175 = sp->sflags;
    D.7180 = D.7175 & 8;
    if (D.7180 == 0) goto <D.7181>; else goto <D.7182>;
    <D.7181>:
    {
      struct malloc_chunk * p;
      size_t psize;

      D.7184 = base + 16;
      D.7185 = (long unsigned int) D.7184;
      D.7186 = D.7185 & 7;
      if (D.7186 != 0) goto <D.7187>; else goto <D.7188>;
      <D.7187>:
      D.7184 = base + 16;
      D.7185 = (long unsigned int) D.7184;
      D.7189 = -D.7185;
      iftmp.77 = D.7189 & 7;
      goto <D.7190>;
      <D.7188>:
      iftmp.77 = 0;
      <D.7190>:
      p = base + iftmp.77;
      D.7191 = p->head;
      psize = D.7191 & 18446744073709551612;
      D.7191 = p->head;
      D.7192 = D.7191 & 2;
      if (D.7192 == 0) goto <D.7193>; else goto <D.7194>;
      <D.7193>:
      D.7195 = p + psize;
      D.7196 = size + 18446744073709551544;
      D.7197 = base + D.7196;
      if (D.7195 >= D.7197) goto <D.7198>; else goto <D.7199>;
      <D.7198>:
      {
        struct malloc_tree_chunk * tp;

        tp = p;
        D.7200 = m->dv;
        if (D.7200 == p) goto <D.7201>; else goto <D.7202>;
        <D.7201>:
        m->dv = 0B;
        m->dvsize = 0;
        goto <D.7203>;
        <D.7202>:
        {
          struct malloc_tree_chunk * XP;
          struct malloc_tree_chunk * R;

          XP = tp->parent;
          D.7204 = tp->bk;
          if (D.7204 != tp) goto <D.7205>; else goto <D.7206>;
          <D.7205>:
          {
            struct malloc_tree_chunk * F;

            F = tp->fd;
            R = tp->bk;
            D.7207 = m->least_addr;
            D.7208 = D.7207 <= F;
            D.7209 = (long int) D.7208;
            D.7210 = __builtin_expect (D.7209, 1);
            if (D.7210 != 0) goto <D.7211>; else goto <D.7212>;
            <D.7211>:
            F->bk = R;
            R->fd = F;
            goto <D.7213>;
            <D.7212>:
            abort ();
            <D.7213>:
          }
          goto <D.7214>;
          <D.7206>:
          {
            struct malloc_tree_chunk * * RP;

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

              goto <D.5350>;
              <D.5349>:
              RP = CP;
              R = *RP;
              <D.5350>:
              CP = &R->child[1];
              D.7218 = *CP;
              if (D.7218 != 0B) goto <D.5349>; else goto <D.7219>;
              <D.7219>:
              CP = &R->child[0];
              D.7218 = *CP;
              if (D.7218 != 0B) goto <D.5349>; else goto <D.5351>;
              <D.5351>:
              D.7207 = m->least_addr;
              D.7220 = D.7207 <= RP;
              D.7221 = (long int) D.7220;
              D.7222 = __builtin_expect (D.7221, 1);
              if (D.7222 != 0) goto <D.7223>; else goto <D.7224>;
              <D.7223>:
              *RP = 0B;
              goto <D.7225>;
              <D.7224>:
              abort ();
              <D.7225>:
            }
            <D.7216>:
          }
          <D.7214>:
          if (XP != 0B) goto <D.7226>; else goto <D.7227>;
          <D.7226>:
          {
            struct malloc_tree_chunk * * H;

            D.7228 = tp->index;
            H = &m->treebins[D.7228];
            D.7229 = *H;
            if (D.7229 == tp) goto <D.7230>; else goto <D.7231>;
            <D.7230>:
            *H = R;
            D.7229 = *H;
            if (D.7229 == 0B) goto <D.7232>; else goto <D.7233>;
            <D.7232>:
            D.7234 = m->treemap;
            D.7228 = tp->index;
            D.7235 = (int) D.7228;
            D.7236 = 1 << D.7235;
            D.7237 = ~D.7236;
            D.7238 = D.7234 & D.7237;
            m->treemap = D.7238;
            <D.7233>:
            goto <D.7239>;
            <D.7231>:
            D.7207 = m->least_addr;
            D.7240 = D.7207 <= XP;
            D.7241 = (long int) D.7240;
            D.7242 = __builtin_expect (D.7241, 1);
            if (D.7242 != 0) goto <D.7243>; else goto <D.7244>;
            <D.7243>:
            D.7245 = XP->child[0];
            if (D.7245 == tp) goto <D.7246>; else goto <D.7247>;
            <D.7246>:
            XP->child[0] = R;
            goto <D.7248>;
            <D.7247>:
            XP->child[1] = R;
            <D.7248>:
            goto <D.7249>;
            <D.7244>:
            abort ();
            <D.7249>:
            <D.7239>:
            if (R != 0B) goto <D.7250>; else goto <D.7251>;
            <D.7250>:
            D.7207 = m->least_addr;
            D.7252 = D.7207 <= R;
            D.7253 = (long int) D.7252;
            D.7254 = __builtin_expect (D.7253, 1);
            if (D.7254 != 0) goto <D.7255>; else goto <D.7256>;
            <D.7255>:
            {
              struct malloc_tree_chunk * C0;
              struct malloc_tree_chunk * C1;

              R->parent = XP;
              C0 = tp->child[0];
              if (C0 != 0B) goto <D.7257>; else goto <D.7258>;
              <D.7257>:
              D.7207 = m->least_addr;
              D.7259 = D.7207 <= C0;
              D.7260 = (long int) D.7259;
              D.7261 = __builtin_expect (D.7260, 1);
              if (D.7261 != 0) goto <D.7262>; else goto <D.7263>;
              <D.7262>:
              R->child[0] = C0;
              C0->parent = R;
              goto <D.7264>;
              <D.7263>:
              abort ();
              <D.7264>:
              <D.7258>:
              C1 = tp->child[1];
              if (C1 != 0B) goto <D.7265>; else goto <D.7266>;
              <D.7265>:
              D.7207 = m->least_addr;
              D.7267 = D.7207 <= C1;
              D.7268 = (long int) D.7267;
              D.7269 = __builtin_expect (D.7268, 1);
              if (D.7269 != 0) goto <D.7270>; else goto <D.7271>;
              <D.7270>:
              R->child[1] = C1;
              C1->parent = R;
              goto <D.7272>;
              <D.7271>:
              abort ();
              <D.7272>:
              <D.7266>:
            }
            goto <D.7273>;
            <D.7256>:
            abort ();
            <D.7273>:
            <D.7251>:
          }
          <D.7227>:
        }
        <D.7203>:
        D.7274 = munmap (base, size);
        if (D.7274 == 0) goto <D.7275>; else goto <D.7276>;
        <D.7275>:
        released = released + size;
        D.7277 = m->footprint;
        D.7278 = D.7277 - size;
        m->footprint = D.7278;
        sp = pred;
        sp->next = next;
        goto <D.7279>;
        <D.7276>:
        {
          struct malloc_tree_chunk * * H;
          bindex_t I;

          {
            size_t X;

            X = psize >> 8;
            if (X == 0) goto <D.7280>; else goto <D.7281>;
            <D.7280>:
            I = 0;
            goto <D.7282>;
            <D.7281>:
            if (X > 65535) goto <D.7283>; else goto <D.7284>;
            <D.7283>:
            I = 31;
            goto <D.7285>;
            <D.7284>:
            {
              unsigned int Y;
              unsigned int N;
              unsigned int K;

              Y = (unsigned int) X;
              D.7286 = Y + 4294967040;
              D.7287 = D.7286 >> 16;
              N = D.7287 & 8;
              N.78 = (int) N;
              Y = Y << N.78;
              D.7289 = Y + 4294963200;
              D.7290 = D.7289 >> 16;
              K = D.7290 & 4;
              N = N + K;
              K.79 = (int) K;
              Y = Y << K.79;
              D.7292 = Y + 4294950912;
              D.7293 = D.7292 >> 16;
              K = D.7293 & 2;
              K.80 = K;
              N = K.80 + N;
              K.79 = (int) K;
              Y = Y << K.79;
              D.7295 = Y >> 15;
              D.7296 = D.7295 - N;
              K = D.7296 + 14;
              D.7297 = K << 1;
              D.7298 = K + 7;
              D.7299 = (int) D.7298;
              D.7300 = psize >> D.7299;
              D.7301 = (unsigned int) D.7300;
              D.7302 = D.7301 & 1;
              I = D.7297 + D.7302;
            }
            <D.7285>:
            <D.7282>:
          }
          H = &m->treebins[I];
          tp->index = I;
          tp->child[1] = 0B;
          D.7303 = tp->child[1];
          tp->child[0] = D.7303;
          D.7234 = m->treemap;
          I.81 = (int) I;
          D.7305 = 1 << I.81;
          D.7306 = D.7234 & D.7305;
          if (D.7306 == 0) goto <D.7307>; else goto <D.7308>;
          <D.7307>:
          D.7234 = m->treemap;
          I.81 = (int) I;
          D.7305 = 1 << I.81;
          D.7309 = D.7234 | D.7305;
          m->treemap = D.7309;
          *H = tp;
          tp->parent = H;
          tp->bk = tp;
          D.7204 = tp->bk;
          tp->fd = D.7204;
          goto <D.7310>;
          <D.7308>:
          {
            struct malloc_tree_chunk * T;
            size_t K;

            T = *H;
            if (I != 31) goto <D.7312>; else goto <D.7313>;
            <D.7312>:
            D.7314 = I >> 1;
            D.7315 = D.7314 + 6;
            D.7316 = (long unsigned int) D.7315;
            D.7317 = 63 - D.7316;
            iftmp.82 = (int) D.7317;
            goto <D.7318>;
            <D.7313>:
            iftmp.82 = 0;
            <D.7318>:
            K = psize << iftmp.82;
            <D.5366>:
            D.7319 = T->head;
            D.7320 = D.7319 & 18446744073709551612;
            if (D.7320 != psize) goto <D.7321>; else goto <D.7322>;
            <D.7321>:
            {
              struct malloc_tree_chunk * * C;

              D.7323 = K >> 63;
              C = &T->child[D.7323];
              K = K << 1;
              D.7324 = *C;
              if (D.7324 != 0B) goto <D.7325>; else goto <D.7326>;
              <D.7325>:
              T = *C;
              goto <D.7327>;
              <D.7326>:
              D.7207 = m->least_addr;
              D.7328 = D.7207 <= C;
              D.7329 = (long int) D.7328;
              D.7330 = __builtin_expect (D.7329, 1);
              if (D.7330 != 0) goto <D.7331>; else goto <D.7332>;
              <D.7331>:
              *C = tp;
              tp->parent = T;
              tp->bk = tp;
              D.7204 = tp->bk;
              tp->fd = D.7204;
              goto <D.5364>;
              <D.7332>:
              abort ();
              <D.7327>:
            }
            goto <D.7333>;
            <D.7322>:
            {
              struct malloc_tree_chunk * F;

              F = T->fd;
              D.7207 = m->least_addr;
              D.7335 = D.7207 <= T;
              D.7336 = (long int) D.7335;
              D.7337 = __builtin_expect (D.7336, 1);
              if (D.7337 != 0) goto <D.7338>; else goto <D.7334>;
              <D.7338>:
              D.7207 = m->least_addr;
              D.7339 = D.7207 <= F;
              D.7340 = (long int) D.7339;
              D.7341 = __builtin_expect (D.7340, 1);
              if (D.7341 != 0) goto <D.7342>; else goto <D.7334>;
              <D.7342>:
              F->bk = tp;
              D.7343 = F->bk;
              T->fd = D.7343;
              tp->fd = F;
              tp->bk = T;
              tp->parent = 0B;
              goto <D.5364>;
              <D.7334>:
              abort ();
            }
            <D.7333>:
            goto <D.5366>;
            <D.5364>:
          }
          <D.7310>:
        }
        <D.7279>:
      }
      <D.7199>:
      <D.7194>:
    }
    <D.7182>:
    <D.7179>:
    pred = sp;
    sp = next;
  }
  <D.5368>:
  if (sp != 0B) goto <D.5367>; else goto <D.5369>;
  <D.5369>:
  D.7344 = released;
  return D.7344;
}


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

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


internal_memalign (struct malloc_state * m, size_t alignment, size_t bytes)
{
  void * D.7350;
  long unsigned int D.7353;
  long unsigned int D.7354;
  long unsigned int D.7357;
  int * D.7362;
  long unsigned int iftmp.83;
  long unsigned int D.7367;
  long unsigned int D.7369;
  long unsigned int D.7375;
  int D.7377;
  unsigned int D.7378;
  unsigned int D.7379;
  union pthread_mutex_t * D.7380;
  int D.7381;
  long unsigned int mem.84;
  long unsigned int D.7385;
  sizetype D.7388;
  char * D.7389;
  long unsigned int D.7390;
  long unsigned int D.7391;
  long unsigned int D.7392;
  sizetype D.7393;
  char * iftmp.85;
  long int br.86;
  long int p.87;
  long int D.7397;
  long unsigned int D.7398;
  long int pos.88;
  long int D.7403;
  long unsigned int D.7404;
  long unsigned int D.7405;
  long unsigned int D.7408;
  long unsigned int D.7410;
  long unsigned int D.7411;
  long unsigned int D.7413;
  long unsigned int D.7414;
  long unsigned int D.7415;
  long unsigned int D.7416;
  long unsigned int D.7417;
  long unsigned int D.7418;
  struct malloc_chunk * D.7419;
  long unsigned int D.7420;
  long unsigned int D.7421;
  long unsigned int D.7422;
  long unsigned int D.7423;
  struct malloc_chunk * D.7424;
  long unsigned int D.7425;
  long unsigned int D.7426;
  long unsigned int D.7430;
  long unsigned int D.7433;
  long unsigned int D.7434;
  struct malloc_chunk * D.7435;
  long unsigned int D.7436;
  long unsigned int D.7437;
  long unsigned int D.7438;
  long unsigned int D.7439;
  long unsigned int D.7440;
  long unsigned int D.7441;
  struct malloc_chunk * D.7442;
  long unsigned int D.7443;
  long unsigned int D.7444;

  if (alignment <= 8) goto <D.7348>; else goto <D.7349>;
  <D.7348>:
  D.7350 = dlmalloc (bytes);
  return D.7350;
  <D.7349>:
  if (alignment <= 31) goto <D.7351>; else goto <D.7352>;
  <D.7351>:
  alignment = 32;
  <D.7352>:
  D.7353 = alignment + 18446744073709551615;
  D.7354 = D.7353 & alignment;
  if (D.7354 != 0) goto <D.7355>; else goto <D.7356>;
  <D.7355>:
  {
    size_t a;

    a = 16;
    goto <D.5478>;
    <D.5477>:
    a = a << 1;
    <D.5478>:
    if (a < alignment) goto <D.5477>; else goto <D.5479>;
    <D.5479>:
    alignment = a;
  }
  <D.7356>:
  D.7357 = 18446744073709551488 - alignment;
  if (D.7357 <= bytes) goto <D.7358>; else goto <D.7359>;
  <D.7358>:
  if (m != 0B) goto <D.7360>; else goto <D.7361>;
  <D.7360>:
  D.7362 = __errno_location ();
  *D.7362 = 12;
  <D.7361>:
  goto <D.7363>;
  <D.7359>:
  {
    size_t nb;
    size_t req;
    char * mem;

    if (bytes > 22) goto <D.7365>; else goto <D.7366>;
    <D.7365>:
    D.7367 = bytes + 15;
    iftmp.83 = D.7367 & 18446744073709551608;
    goto <D.7368>;
    <D.7366>:
    iftmp.83 = 32;
    <D.7368>:
    nb = iftmp.83;
    D.7369 = nb + alignment;
    req = D.7369 + 24;
    mem = dlmalloc (req);
    if (mem != 0B) goto <D.7370>; else goto <D.7371>;
    <D.7370>:
    {
      void * leader;
      void * trailer;
      struct malloc_chunk * p;

      leader = 0B;
      trailer = 0B;
      p = mem + 18446744073709551600;
      D.7375 = mparams.page_size;
      if (D.7375 == 0) goto <D.7376>; else goto <D.7372>;
      <D.7376>:
      D.7377 = init_mparams ();
      if (D.7377 != 0) goto <D.7373>; else goto <D.7372>;
      <D.7372>:
      D.7378 = m->mflags;
      D.7379 = D.7378 & 2;
      if (D.7379 != 0) goto <D.7373>; else goto <D.7374>;
      <D.7373>:
      D.7380 = &m->mutex;
      D.7381 = pthread_mutex_lock (D.7380);
      if (D.7381 != 0) goto <D.7382>; else goto <D.7383>;
      <D.7382>:
      D.7350 = 0B;
      return D.7350;
      <D.7383>:
      <D.7374>:
      mem.84 = (long unsigned int) mem;
      D.7385 = mem.84 % alignment;
      if (D.7385 != 0) goto <D.7386>; else goto <D.7387>;
      <D.7386>:
      {
        char * br;
        char * pos;
        struct malloc_chunk * newp;
        size_t leadsize;
        size_t newsize;

        D.7388 = alignment + 18446744073709551615;
        D.7389 = mem + D.7388;
        D.7390 = (long unsigned int) D.7389;
        D.7391 = -alignment;
        D.7392 = D.7390 & D.7391;
        D.7393 = D.7392 + 18446744073709551600;
        br = (char *) D.7393;
        br.86 = (long int) br;
        p.87 = (long int) p;
        D.7397 = br.86 - p.87;
        D.7398 = (long unsigned int) D.7397;
        if (D.7398 <= 31) goto <D.7399>; else goto <D.7400>;
        <D.7399>:
        iftmp.85 = br + alignment;
        goto <D.7401>;
        <D.7400>:
        iftmp.85 = br;
        <D.7401>:
        pos = iftmp.85;
        newp = pos;
        pos.88 = (long int) pos;
        p.87 = (long int) p;
        D.7403 = pos.88 - p.87;
        leadsize = (size_t) D.7403;
        D.7404 = p->head;
        D.7405 = D.7404 & 18446744073709551612;
        newsize = D.7405 - leadsize;
        D.7404 = p->head;
        D.7408 = D.7404 & 1;
        if (D.7408 == 0) goto <D.7409>; else goto <D.7406>;
        <D.7409>:
        D.7410 = p->prev_foot;
        D.7411 = D.7410 & 1;
        if (D.7411 != 0) goto <D.7412>; else goto <D.7406>;
        <D.7412>:
        D.7410 = p->prev_foot;
        D.7413 = D.7410 + leadsize;
        newp->prev_foot = D.7413;
        D.7414 = newsize | 2;
        newp->head = D.7414;
        goto <D.7407>;
        <D.7406>:
        D.7415 = newp->head;
        D.7416 = D.7415 & 1;
        D.7417 = D.7416 | newsize;
        D.7418 = D.7417 | 2;
        newp->head = D.7418;
        D.7419 = newp + newsize;
        D.7419 = newp + newsize;
        D.7420 = D.7419->head;
        D.7421 = D.7420 | 1;
        D.7419->head = D.7421;
        D.7404 = p->head;
        D.7408 = D.7404 & 1;
        D.7422 = D.7408 | leadsize;
        D.7423 = D.7422 | 2;
        p->head = D.7423;
        D.7424 = p + leadsize;
        D.7424 = p + leadsize;
        D.7425 = D.7424->head;
        D.7426 = D.7425 | 1;
        D.7424->head = D.7426;
        leader = p + 16;
        <D.7407>:
        p = newp;
      }
      <D.7387>:
      D.7404 = p->head;
      D.7408 = D.7404 & 1;
      if (D.7408 != 0) goto <D.7427>; else goto <D.7429>;
      <D.7429>:
      D.7410 = p->prev_foot;
      D.7411 = D.7410 & 1;
      if (D.7411 == 0) goto <D.7427>; else goto <D.7428>;
      <D.7427>:
      {
        size_t size;

        D.7404 = p->head;
        size = D.7404 & 18446744073709551612;
        D.7430 = nb + 32;
        if (D.7430 < size) goto <D.7431>; else goto <D.7432>;
        <D.7431>:
        {
          size_t remainder_size;
          struct malloc_chunk * remainder;

          remainder_size = size - nb;
          remainder = p + nb;
          D.7404 = p->head;
          D.7408 = D.7404 & 1;
          D.7433 = D.7408 | nb;
          D.7434 = D.7433 | 2;
          p->head = D.7434;
          D.7435 = p + nb;
          D.7435 = p + nb;
          D.7436 = D.7435->head;
          D.7437 = D.7436 | 1;
          D.7435->head = D.7437;
          D.7438 = remainder->head;
          D.7439 = D.7438 & 1;
          D.7440 = D.7439 | remainder_size;
          D.7441 = D.7440 | 2;
          remainder->head = D.7441;
          D.7442 = remainder + remainder_size;
          D.7442 = remainder + remainder_size;
          D.7443 = D.7442->head;
          D.7444 = D.7443 | 1;
          D.7442->head = D.7444;
          trailer = remainder + 16;
        }
        <D.7432>:
      }
      <D.7428>:
      D.7378 = m->mflags;
      D.7379 = D.7378 & 2;
      if (D.7379 != 0) goto <D.7445>; else goto <D.7446>;
      <D.7445>:
      D.7380 = &m->mutex;
      pthread_mutex_unlock (D.7380);
      <D.7446>:
      if (leader != 0B) goto <D.7447>; else goto <D.7448>;
      <D.7447>:
      dlfree (leader);
      <D.7448>:
      if (trailer != 0B) goto <D.7449>; else goto <D.7450>;
      <D.7449>:
      dlfree (trailer);
      <D.7450>:
      D.7350 = p + 16;
      return D.7350;
    }
    <D.7371>:
  }
  <D.7363>:
  D.7350 = 0B;
  return D.7350;
}