dlmalloc (size_t bytes)
{
  unsigned int D.5205;
  int D.5207;
  unsigned int D.5208;
  unsigned int D.5209;
  int D.5210;
  unsigned int iftmp.0;
  unsigned int D.5216;
  unsigned int D.5218;
  int idx.1;
  unsigned int D.5220;
  unsigned int D.5223;
  _Bool D.5224;
  unsigned int D.5225;
  unsigned int D.5226;
  unsigned int D.5229;
  unsigned int D.5230;
  unsigned int D.5231;
  char * D.5233;
  _Bool D.5234;
  long int D.5235;
  long int D.5236;
  unsigned int D.5240;
  unsigned int D.5241;
  struct malloc_chunk * D.5242;
  unsigned int D.5243;
  unsigned int D.5244;
  unsigned int D.5245;
  unsigned int D.5250;
  unsigned int D.5251;
  unsigned int D.5252;
  unsigned int D.5253;
  unsigned int D.5254;
  unsigned int D.5255;
  int K.2;
  unsigned int D.5257;
  unsigned int K.3;
  unsigned int D.5259;
  unsigned int K.4;
  unsigned int D.5261;
  unsigned int K.5;
  unsigned int K.6;
  unsigned int D.5264;
  int i.7;
  unsigned int D.5268;
  unsigned int D.5269;
  unsigned int D.5270;
  _Bool D.5272;
  long int D.5273;
  long int D.5274;
  unsigned int D.5278;
  unsigned int D.5281;
  struct malloc_chunk * D.5282;
  unsigned int D.5283;
  unsigned int D.5284;
  unsigned int D.5286;
  unsigned int D.5287;
  struct malloc_chunk * D.5288;
  unsigned int D.5291;
  int I.8;
  unsigned int D.5293;
  unsigned int D.5294;
  unsigned int D.5297;
  struct malloc_chunk * D.5299;
  _Bool D.5300;
  long int D.5301;
  long int D.5302;
  unsigned int D.5306;
  struct malloc_chunk * D.5321;
  unsigned int D.5322;
  struct malloc_chunk * D.5323;
  unsigned int D.5325;
  struct malloc_chunk * D.5326;
  unsigned int D.5327;
  unsigned int D.5328;
  unsigned int D.5329;
  unsigned int D.5332;
  struct malloc_chunk * D.5333;
  unsigned int D.5334;
  void * D.5337;
  void postaction = <<< error >>>;

  D.5205 = mparams.page_size;
  if (D.5205 != 0) goto <D.5201>; else goto <D.5206>;
  <D.5206>:
  D.5207 = init_mparams ();
  if (D.5207 == 0) goto <D.5201>; else goto <D.5202>;
  <D.5201>:
  D.5208 = _gm_.mflags;
  D.5209 = D.5208 & 2;
  if (D.5209 == 0) goto <D.5203>; else goto <D.5202>;
  <D.5202>:
  D.5210 = pthread_mutex_lock (&_gm_.mutex);
  if (D.5210 == 0) goto <D.5203>; else goto <D.5204>;
  <D.5203>:
  {
    void * mem;
    size_t nb;

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

      if (bytes > 10) goto <D.5214>; else goto <D.5215>;
      <D.5214>:
      D.5216 = bytes + 11;
      iftmp.0 = D.5216 & 4294967288;
      goto <D.5217>;
      <D.5215>:
      iftmp.0 = 16;
      <D.5217>:
      nb = iftmp.0;
      idx = nb >> 3;
      D.5218 = _gm_.smallmap;
      idx.1 = (int) idx;
      smallbits = D.5218 >> idx.1;
      D.5220 = smallbits & 3;
      if (D.5220 != 0) goto <D.5221>; else goto <D.5222>;
      <D.5221>:
      {
        struct malloc_chunk * b;
        struct malloc_chunk * p;

        D.5223 = smallbits & 1;
        D.5224 = D.5223 == 0;
        D.5225 = (unsigned int) D.5224;
        idx = D.5225 + idx;
        D.5226 = idx << 1;
        b = &_gm_.smallbins[D.5226];
        p = b->fd;
        {
          struct malloc_chunk * F;

          F = p->fd;
          if (b == F) goto <D.5227>; else goto <D.5228>;
          <D.5227>:
          D.5218 = _gm_.smallmap;
          idx.1 = (int) idx;
          D.5229 = 1 << idx.1;
          D.5230 = ~D.5229;
          D.5231 = D.5218 & D.5230;
          _gm_.smallmap = D.5231;
          goto <D.5232>;
          <D.5228>:
          D.5233 = _gm_.least_addr;
          D.5234 = D.5233 <= F;
          D.5235 = (long int) D.5234;
          D.5236 = __builtin_expect (D.5235, 1);
          if (D.5236 != 0) goto <D.5237>; else goto <D.5238>;
          <D.5237>:
          b->fd = F;
          F->bk = b;
          goto <D.5239>;
          <D.5238>:
          abort ();
          <D.5239>:
          <D.5232>:
        }
        D.5240 = idx << 3;
        D.5241 = D.5240 | 3;
        p->head = D.5241;
        D.5240 = idx << 3;
        D.5242 = p + D.5240;
        D.5240 = idx << 3;
        D.5242 = p + D.5240;
        D.5243 = D.5242->head;
        D.5244 = D.5243 | 1;
        D.5242->head = D.5244;
        mem = p + 8;
        goto postaction;
      }
      <D.5222>:
      D.5245 = _gm_.dvsize;
      if (D.5245 < nb) goto <D.5246>; else goto <D.5247>;
      <D.5246>:
      if (smallbits != 0) goto <D.5248>; else goto <D.5249>;
      <D.5248>:
      {
        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.5250 = smallbits << idx.1;
        idx.1 = (int) idx;
        D.5229 = 1 << idx.1;
        D.5251 = D.5229 << 1;
        idx.1 = (int) idx;
        D.5229 = 1 << idx.1;
        D.5251 = D.5229 << 1;
        D.5252 = -D.5251;
        D.5253 = D.5251 | D.5252;
        leftbits = D.5250 & D.5253;
        D.5254 = -leftbits;
        leastbit = D.5254 & leftbits;
        {
          unsigned int Y;
          unsigned int K;
          unsigned int N;

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

          F = p->fd;
          if (b == F) goto <D.5265>; else goto <D.5266>;
          <D.5265>:
          D.5218 = _gm_.smallmap;
          i.7 = (int) i;
          D.5268 = 1 << i.7;
          D.5269 = ~D.5268;
          D.5270 = D.5218 & D.5269;
          _gm_.smallmap = D.5270;
          goto <D.5271>;
          <D.5266>:
          D.5233 = _gm_.least_addr;
          D.5272 = D.5233 <= F;
          D.5273 = (long int) D.5272;
          D.5274 = __builtin_expect (D.5273, 1);
          if (D.5274 != 0) goto <D.5275>; else goto <D.5276>;
          <D.5275>:
          b->fd = F;
          F->bk = b;
          goto <D.5277>;
          <D.5276>:
          abort ();
          <D.5277>:
          <D.5271>:
        }
        D.5278 = i << 3;
        rsize = D.5278 - nb;
        if (0 != 0) goto <D.5279>; else goto <D.5280>;
        <D.5279>:
        D.5278 = i << 3;
        D.5281 = D.5278 | 3;
        p->head = D.5281;
        D.5278 = i << 3;
        D.5282 = p + D.5278;
        D.5278 = i << 3;
        D.5282 = p + D.5278;
        D.5283 = D.5282->head;
        D.5284 = D.5283 | 1;
        D.5282->head = D.5284;
        goto <D.5285>;
        <D.5280>:
        D.5286 = nb | 3;
        p->head = D.5286;
        r = p + nb;
        D.5287 = rsize | 1;
        r->head = D.5287;
        D.5288 = r + rsize;
        D.5288->prev_foot = rsize;
        {
          size_t DVS;

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

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

              I = DVS >> 3;
              D.5291 = I << 1;
              B = &_gm_.smallbins[D.5291];
              F = B;
              D.5218 = _gm_.smallmap;
              I.8 = (int) I;
              D.5293 = 1 << I.8;
              D.5294 = D.5218 & D.5293;
              if (D.5294 == 0) goto <D.5295>; else goto <D.5296>;
              <D.5295>:
              D.5218 = _gm_.smallmap;
              I.8 = (int) I;
              D.5293 = 1 << I.8;
              D.5297 = D.5218 | D.5293;
              _gm_.smallmap = D.5297;
              goto <D.5298>;
              <D.5296>:
              D.5299 = B->fd;
              D.5233 = _gm_.least_addr;
              D.5300 = D.5299 >= D.5233;
              D.5301 = (long int) D.5300;
              D.5302 = __builtin_expect (D.5301, 1);
              if (D.5302 != 0) goto <D.5303>; else goto <D.5304>;
              <D.5303>:
              F = B->fd;
              goto <D.5305>;
              <D.5304>:
              abort ();
              <D.5305>:
              <D.5298>:
              B->fd = DV;
              F->bk = DV;
              DV->fd = F;
              DV->bk = B;
            }
          }
          <D.5290>:
          _gm_.dvsize = rsize;
          _gm_.dv = r;
        }
        <D.5285>:
        mem = p + 8;
        goto postaction;
      }
      <D.5249>:
      D.5306 = _gm_.treemap;
      if (D.5306 != 0) goto <D.5307>; else goto <D.5308>;
      <D.5307>:
      mem = tmalloc_small (&_gm_, nb);
      if (mem != 0B) goto postaction; else goto <D.5309>;
      <D.5309>:
      <D.5308>:
      <D.5247>:
    }
    goto <D.5310>;
    <D.5212>:
    if (bytes > 4294967231) goto <D.5311>; else goto <D.5312>;
    <D.5311>:
    nb = 4294967295;
    goto <D.5313>;
    <D.5312>:
    D.5216 = bytes + 11;
    nb = D.5216 & 4294967288;
    D.5306 = _gm_.treemap;
    if (D.5306 != 0) goto <D.5314>; else goto <D.5315>;
    <D.5314>:
    mem = tmalloc_large (&_gm_, nb);
    if (mem != 0B) goto postaction; else goto <D.5316>;
    <D.5316>:
    <D.5315>:
    <D.5313>:
    <D.5310>:
    D.5245 = _gm_.dvsize;
    if (D.5245 >= nb) goto <D.5317>; else goto <D.5318>;
    <D.5317>:
    {
      size_t rsize;
      struct malloc_chunk * p;

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

        D.5321 = p + nb;
        _gm_.dv = D.5321;
        r = _gm_.dv;
        _gm_.dvsize = rsize;
        D.5322 = rsize | 1;
        r->head = D.5322;
        D.5323 = r + rsize;
        D.5323->prev_foot = rsize;
        D.5286 = nb | 3;
        p->head = D.5286;
      }
      goto <D.5324>;
      <D.5320>:
      {
        size_t dvs;

        dvs = _gm_.dvsize;
        _gm_.dvsize = 0;
        _gm_.dv = 0B;
        D.5325 = dvs | 3;
        p->head = D.5325;
        D.5326 = p + dvs;
        D.5326 = p + dvs;
        D.5327 = D.5326->head;
        D.5328 = D.5327 | 1;
        D.5326->head = D.5328;
      }
      <D.5324>:
      mem = p + 8;
      goto postaction;
    }
    <D.5318>:
    D.5329 = _gm_.topsize;
    if (D.5329 > nb) goto <D.5330>; else goto <D.5331>;
    <D.5330>:
    {
      size_t rsize;
      struct malloc_chunk * p;
      struct malloc_chunk * r;

      D.5329 = _gm_.topsize;
      D.5332 = D.5329 - nb;
      _gm_.topsize = D.5332;
      rsize = _gm_.topsize;
      p = _gm_.top;
      D.5333 = p + nb;
      _gm_.top = D.5333;
      r = _gm_.top;
      D.5334 = rsize | 1;
      r->head = D.5334;
      D.5286 = nb | 3;
      p->head = D.5286;
      mem = p + 8;
      goto postaction;
    }
    <D.5331>:
    mem = sys_alloc (&_gm_, nb);
    postaction:
    D.5208 = _gm_.mflags;
    D.5209 = D.5208 & 2;
    if (D.5209 != 0) goto <D.5335>; else goto <D.5336>;
    <D.5335>:
    pthread_mutex_unlock (&_gm_.mutex);
    <D.5336>:
    D.5337 = mem;
    return D.5337;
  }
  <D.5204>:
  D.5337 = 0B;
  return D.5337;
}


init_mparams ()
{
  unsigned int D.5339;
  unsigned int D.5342;
  unsigned int D.5345;
  unsigned int D.5348;
  unsigned int D.5349;
  unsigned int D.5350;
  unsigned int D.5352;
  unsigned int D.5353;
  int D.5354;

  D.5339 = mparams.page_size;
  if (D.5339 == 0) goto <D.5340>; else goto <D.5341>;
  <D.5340>:
  {
    size_t s;

    mparams.mmap_threshold = 262144;
    mparams.trim_threshold = 2097152;
    mparams.default_mflags = 7;
    s = 1482184792;
    pthread_mutex_lock (&magic_init_mutex);
    D.5342 = mparams.magic;
    if (D.5342 == 0) goto <D.5343>; else goto <D.5344>;
    <D.5343>:
    mparams.magic = s;
    pthread_mutex_init (&_gm_.mutex, 0B);
    D.5345 = mparams.default_mflags;
    _gm_.mflags = D.5345;
    <D.5344>:
    pthread_mutex_unlock (&magic_init_mutex);
    mparams.page_size = 65536;
    mparams.granularity = 65536;
    D.5348 = mparams.granularity;
    D.5348 = mparams.granularity;
    D.5349 = D.5348 + 4294967295;
    D.5350 = D.5348 & D.5349;
    if (D.5350 != 0) goto <D.5346>; else goto <D.5351>;
    <D.5351>:
    D.5339 = mparams.page_size;
    D.5339 = mparams.page_size;
    D.5352 = D.5339 + 4294967295;
    D.5353 = D.5339 & D.5352;
    if (D.5353 != 0) goto <D.5346>; else goto <D.5347>;
    <D.5346>:
    abort ();
    <D.5347>:
  }
  <D.5341>:
  D.5354 = 0;
  return D.5354;
}


tmalloc_small (struct malloc_state * m, size_t nb)
{
  unsigned int D.5356;
  unsigned int D.5357;
  unsigned int D.5358;
  int K.9;
  unsigned int D.5360;
  unsigned int K.10;
  unsigned int D.5362;
  unsigned int K.11;
  unsigned int D.5364;
  unsigned int K.12;
  unsigned int K.13;
  unsigned int D.5367;
  unsigned int D.5368;
  struct malloc_tree_chunk * iftmp.14;
  struct malloc_tree_chunk * D.5372;
  char * D.5376;
  _Bool D.5377;
  long int D.5378;
  long int D.5379;
  _Bool D.5382;
  long int D.5383;
  long int D.5384;
  struct malloc_tree_chunk * D.5387;
  _Bool D.5390;
  long int D.5391;
  long int D.5392;
  struct malloc_tree_chunk * D.5400;
  _Bool D.5402;
  long int D.5403;
  long int D.5404;
  unsigned int D.5410;
  struct malloc_tree_chunk * D.5411;
  int D.5416;
  unsigned int D.5417;
  unsigned int D.5418;
  unsigned int D.5419;
  _Bool D.5421;
  long int D.5422;
  long int D.5423;
  struct malloc_tree_chunk * D.5426;
  _Bool D.5433;
  long int D.5434;
  long int D.5435;
  _Bool D.5440;
  long int D.5441;
  long int D.5442;
  _Bool D.5448;
  long int D.5449;
  long int D.5450;
  unsigned int D.5457;
  unsigned int D.5458;
  struct malloc_chunk * D.5459;
  unsigned int D.5460;
  unsigned int D.5461;
  unsigned int D.5463;
  unsigned int D.5464;
  struct malloc_chunk * D.5465;
  unsigned int D.5468;
  unsigned int D.5469;
  int I.15;
  unsigned int D.5471;
  unsigned int D.5472;
  unsigned int D.5475;
  struct malloc_chunk * D.5477;
  _Bool D.5478;
  long int D.5479;
  long int D.5480;
  void * D.5484;
  struct malloc_tree_chunk * t;
  struct malloc_tree_chunk * v;
  size_t rsize;
  bindex_t i;
  binmap_t leastbit;

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

    Y = leastbit + 4294967295;
    D.5358 = Y >> 12;
    K = D.5358 & 16;
    N = K;
    K.9 = (int) K;
    Y = Y >> K.9;
    D.5360 = Y >> 5;
    K = D.5360 & 8;
    K.10 = K;
    N = K.10 + N;
    K.9 = (int) K;
    Y = Y >> K.9;
    D.5362 = Y >> 2;
    K = D.5362 & 4;
    K.11 = K;
    N = K.11 + N;
    K.9 = (int) K;
    Y = Y >> K.9;
    D.5364 = Y >> 1;
    K = D.5364 & 2;
    K.12 = K;
    N = K.12 + N;
    K.9 = (int) K;
    Y = Y >> K.9;
    D.5364 = Y >> 1;
    K = D.5364 & 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.5367 = t->head;
  D.5368 = D.5367 & 4294967292;
  rsize = D.5368 - nb;
  goto <D.5061>;
  <D.5060>:
  {
    size_t trem;

    D.5367 = t->head;
    D.5368 = D.5367 & 4294967292;
    trem = D.5368 - nb;
    if (trem < rsize) goto <D.5369>; else goto <D.5370>;
    <D.5369>:
    rsize = trem;
    v = t;
    <D.5370>:
  }
  <D.5061>:
  D.5372 = t->child[0];
  if (D.5372 != 0B) goto <D.5373>; else goto <D.5374>;
  <D.5373>:
  iftmp.14 = t->child[0];
  goto <D.5375>;
  <D.5374>:
  iftmp.14 = t->child[1];
  <D.5375>:
  t = iftmp.14;
  if (t != 0B) goto <D.5060>; else goto <D.5062>;
  <D.5062>:
  D.5376 = m->least_addr;
  D.5377 = D.5376 <= v;
  D.5378 = (long int) D.5377;
  D.5379 = __builtin_expect (D.5378, 1);
  if (D.5379 != 0) goto <D.5380>; else goto <D.5381>;
  <D.5380>:
  {
    struct malloc_chunk * r;

    r = v + nb;
    D.5382 = v < r;
    D.5383 = (long int) D.5382;
    D.5384 = __builtin_expect (D.5383, 1);
    if (D.5384 != 0) goto <D.5385>; else goto <D.5386>;
    <D.5385>:
    {
      struct malloc_tree_chunk * XP;
      struct malloc_tree_chunk * R;

      XP = v->parent;
      D.5387 = v->bk;
      if (D.5387 != v) goto <D.5388>; else goto <D.5389>;
      <D.5388>:
      {
        struct malloc_tree_chunk * F;

        F = v->fd;
        R = v->bk;
        D.5376 = m->least_addr;
        D.5390 = D.5376 <= F;
        D.5391 = (long int) D.5390;
        D.5392 = __builtin_expect (D.5391, 1);
        if (D.5392 != 0) goto <D.5393>; else goto <D.5394>;
        <D.5393>:
        F->bk = R;
        R->fd = F;
        goto <D.5395>;
        <D.5394>:
        abort ();
        <D.5395>:
      }
      goto <D.5396>;
      <D.5389>:
      {
        struct malloc_tree_chunk * * RP;

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

          goto <D.5070>;
          <D.5069>:
          RP = CP;
          R = *RP;
          <D.5070>:
          CP = &R->child[1];
          D.5400 = *CP;
          if (D.5400 != 0B) goto <D.5069>; else goto <D.5401>;
          <D.5401>:
          CP = &R->child[0];
          D.5400 = *CP;
          if (D.5400 != 0B) goto <D.5069>; else goto <D.5071>;
          <D.5071>:
          D.5376 = m->least_addr;
          D.5402 = D.5376 <= RP;
          D.5403 = (long int) D.5402;
          D.5404 = __builtin_expect (D.5403, 1);
          if (D.5404 != 0) goto <D.5405>; else goto <D.5406>;
          <D.5405>:
          *RP = 0B;
          goto <D.5407>;
          <D.5406>:
          abort ();
          <D.5407>:
        }
        <D.5398>:
      }
      <D.5396>:
      if (XP != 0B) goto <D.5408>; else goto <D.5409>;
      <D.5408>:
      {
        struct malloc_tree_chunk * * H;

        D.5410 = v->index;
        H = &m->treebins[D.5410];
        D.5411 = *H;
        if (D.5411 == v) goto <D.5412>; else goto <D.5413>;
        <D.5412>:
        *H = R;
        D.5411 = *H;
        if (D.5411 == 0B) goto <D.5414>; else goto <D.5415>;
        <D.5414>:
        D.5356 = m->treemap;
        D.5410 = v->index;
        D.5416 = (int) D.5410;
        D.5417 = 1 << D.5416;
        D.5418 = ~D.5417;
        D.5419 = D.5356 & D.5418;
        m->treemap = D.5419;
        <D.5415>:
        goto <D.5420>;
        <D.5413>:
        D.5376 = m->least_addr;
        D.5421 = D.5376 <= XP;
        D.5422 = (long int) D.5421;
        D.5423 = __builtin_expect (D.5422, 1);
        if (D.5423 != 0) goto <D.5424>; else goto <D.5425>;
        <D.5424>:
        D.5426 = XP->child[0];
        if (D.5426 == v) goto <D.5427>; else goto <D.5428>;
        <D.5427>:
        XP->child[0] = R;
        goto <D.5429>;
        <D.5428>:
        XP->child[1] = R;
        <D.5429>:
        goto <D.5430>;
        <D.5425>:
        abort ();
        <D.5430>:
        <D.5420>:
        if (R != 0B) goto <D.5431>; else goto <D.5432>;
        <D.5431>:
        D.5376 = m->least_addr;
        D.5433 = D.5376 <= R;
        D.5434 = (long int) D.5433;
        D.5435 = __builtin_expect (D.5434, 1);
        if (D.5435 != 0) goto <D.5436>; else goto <D.5437>;
        <D.5436>:
        {
          struct malloc_tree_chunk * C0;
          struct malloc_tree_chunk * C1;

          R->parent = XP;
          C0 = v->child[0];
          if (C0 != 0B) goto <D.5438>; else goto <D.5439>;
          <D.5438>:
          D.5376 = m->least_addr;
          D.5440 = D.5376 <= C0;
          D.5441 = (long int) D.5440;
          D.5442 = __builtin_expect (D.5441, 1);
          if (D.5442 != 0) goto <D.5443>; else goto <D.5444>;
          <D.5443>:
          R->child[0] = C0;
          C0->parent = R;
          goto <D.5445>;
          <D.5444>:
          abort ();
          <D.5445>:
          <D.5439>:
          C1 = v->child[1];
          if (C1 != 0B) goto <D.5446>; else goto <D.5447>;
          <D.5446>:
          D.5376 = m->least_addr;
          D.5448 = D.5376 <= C1;
          D.5449 = (long int) D.5448;
          D.5450 = __builtin_expect (D.5449, 1);
          if (D.5450 != 0) goto <D.5451>; else goto <D.5452>;
          <D.5451>:
          R->child[1] = C1;
          C1->parent = R;
          goto <D.5453>;
          <D.5452>:
          abort ();
          <D.5453>:
          <D.5447>:
        }
        goto <D.5454>;
        <D.5437>:
        abort ();
        <D.5454>:
        <D.5432>:
      }
      <D.5409>:
    }
    if (rsize <= 15) goto <D.5455>; else goto <D.5456>;
    <D.5455>:
    D.5457 = rsize + nb;
    D.5458 = D.5457 | 3;
    v->head = D.5458;
    D.5457 = rsize + nb;
    D.5459 = v + D.5457;
    D.5457 = rsize + nb;
    D.5459 = v + D.5457;
    D.5460 = D.5459->head;
    D.5461 = D.5460 | 1;
    D.5459->head = D.5461;
    goto <D.5462>;
    <D.5456>:
    D.5463 = nb | 3;
    v->head = D.5463;
    D.5464 = rsize | 1;
    r->head = D.5464;
    D.5465 = r + rsize;
    D.5465->prev_foot = rsize;
    {
      size_t DVS;

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

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

          I = DVS >> 3;
          D.5468 = I << 1;
          B = &m->smallbins[D.5468];
          F = B;
          D.5469 = m->smallmap;
          I.15 = (int) I;
          D.5471 = 1 << I.15;
          D.5472 = D.5469 & D.5471;
          if (D.5472 == 0) goto <D.5473>; else goto <D.5474>;
          <D.5473>:
          D.5469 = m->smallmap;
          I.15 = (int) I;
          D.5471 = 1 << I.15;
          D.5475 = D.5469 | D.5471;
          m->smallmap = D.5475;
          goto <D.5476>;
          <D.5474>:
          D.5477 = B->fd;
          D.5376 = m->least_addr;
          D.5478 = D.5477 >= D.5376;
          D.5479 = (long int) D.5478;
          D.5480 = __builtin_expect (D.5479, 1);
          if (D.5480 != 0) goto <D.5481>; else goto <D.5482>;
          <D.5481>:
          F = B->fd;
          goto <D.5483>;
          <D.5482>:
          abort ();
          <D.5483>:
          <D.5476>:
          B->fd = DV;
          F->bk = DV;
          DV->fd = F;
          DV->bk = B;
        }
      }
      <D.5467>:
      m->dvsize = rsize;
      m->dv = r;
    }
    <D.5462>:
    D.5484 = v + 8;
    return D.5484;
    <D.5386>:
  }
  <D.5381>:
  abort ();
  D.5484 = 0B;
  return D.5484;
}


tmalloc_large (struct malloc_state * m, size_t nb)
{
  unsigned int D.5492;
  unsigned int D.5493;
  int N.16;
  unsigned int D.5495;
  unsigned int D.5496;
  int K.17;
  unsigned int D.5498;
  unsigned int D.5499;
  unsigned int K.18;
  unsigned int D.5501;
  unsigned int D.5502;
  unsigned int D.5503;
  unsigned int D.5504;
  int D.5505;
  unsigned int D.5506;
  unsigned int D.5507;
  int iftmp.19;
  unsigned int D.5513;
  unsigned int D.5514;
  unsigned int D.5516;
  unsigned int D.5517;
  unsigned int D.5521;
  int idx.20;
  unsigned int D.5533;
  unsigned int D.5534;
  unsigned int D.5535;
  unsigned int D.5536;
  unsigned int D.5537;
  unsigned int D.5540;
  unsigned int D.5541;
  int K.21;
  unsigned int D.5543;
  unsigned int K.22;
  unsigned int D.5545;
  unsigned int K.23;
  unsigned int D.5547;
  unsigned int K.24;
  unsigned int K.25;
  struct malloc_tree_chunk * iftmp.26;
  struct malloc_tree_chunk * D.5553;
  unsigned int D.5559;
  unsigned int D.5560;
  char * D.5563;
  _Bool D.5564;
  long int D.5565;
  long int D.5566;
  _Bool D.5569;
  long int D.5570;
  long int D.5571;
  struct malloc_tree_chunk * D.5574;
  _Bool D.5577;
  long int D.5578;
  long int D.5579;
  struct malloc_tree_chunk * D.5587;
  _Bool D.5589;
  long int D.5590;
  long int D.5591;
  unsigned int D.5597;
  struct malloc_tree_chunk * D.5598;
  int D.5603;
  unsigned int D.5604;
  unsigned int D.5605;
  unsigned int D.5606;
  _Bool D.5608;
  long int D.5609;
  long int D.5610;
  struct malloc_tree_chunk * D.5613;
  _Bool D.5620;
  long int D.5621;
  long int D.5622;
  _Bool D.5627;
  long int D.5628;
  long int D.5629;
  _Bool D.5635;
  long int D.5636;
  long int D.5637;
  unsigned int D.5644;
  unsigned int D.5645;
  struct malloc_chunk * D.5646;
  unsigned int D.5647;
  unsigned int D.5648;
  unsigned int D.5650;
  unsigned int D.5651;
  struct malloc_chunk * D.5652;
  unsigned int D.5653;
  unsigned int D.5656;
  unsigned int D.5657;
  int I.27;
  unsigned int D.5659;
  unsigned int D.5660;
  unsigned int D.5663;
  struct malloc_chunk * D.5665;
  _Bool D.5666;
  long int D.5667;
  long int D.5668;
  unsigned int D.5679;
  unsigned int D.5680;
  int N.28;
  unsigned int D.5682;
  unsigned int D.5683;
  int K.29;
  unsigned int D.5685;
  unsigned int D.5686;
  unsigned int K.30;
  unsigned int D.5688;
  unsigned int D.5689;
  unsigned int D.5690;
  unsigned int D.5691;
  int D.5692;
  unsigned int D.5693;
  unsigned int D.5694;
  struct malloc_tree_chunk * D.5695;
  int I.31;
  unsigned int D.5697;
  unsigned int D.5698;
  unsigned int D.5701;
  struct malloc_tree_chunk * D.5702;
  int iftmp.32;
  unsigned int D.5707;
  unsigned int D.5708;
  unsigned int D.5710;
  unsigned int D.5711;
  unsigned int D.5714;
  struct malloc_tree_chunk * D.5715;
  _Bool D.5719;
  long int D.5720;
  long int D.5721;
  _Bool D.5726;
  long int D.5727;
  long int D.5728;
  _Bool D.5730;
  long int D.5731;
  long int D.5732;
  struct malloc_tree_chunk * D.5734;
  void * D.5735;
  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.5486>; else goto <D.5487>;
    <D.5486>:
    idx = 0;
    goto <D.5488>;
    <D.5487>:
    if (X > 65535) goto <D.5489>; else goto <D.5490>;
    <D.5489>:
    idx = 31;
    goto <D.5491>;
    <D.5490>:
    {
      unsigned int Y;
      unsigned int N;
      unsigned int K;

      Y = X;
      D.5492 = Y + 4294967040;
      D.5493 = D.5492 >> 16;
      N = D.5493 & 8;
      N.16 = (int) N;
      Y = Y << N.16;
      D.5495 = Y + 4294963200;
      D.5496 = D.5495 >> 16;
      K = D.5496 & 4;
      N = N + K;
      K.17 = (int) K;
      Y = Y << K.17;
      D.5498 = Y + 4294950912;
      D.5499 = D.5498 >> 16;
      K = D.5499 & 2;
      K.18 = K;
      N = K.18 + N;
      K.17 = (int) K;
      Y = Y << K.17;
      D.5501 = Y >> 15;
      D.5502 = D.5501 - N;
      K = D.5502 + 14;
      D.5503 = K << 1;
      D.5504 = K + 7;
      D.5505 = (int) D.5504;
      D.5506 = nb >> D.5505;
      D.5507 = D.5506 & 1;
      idx = D.5503 + D.5507;
    }
    <D.5491>:
    <D.5488>:
  }
  t = m->treebins[idx];
  if (t != 0B) goto <D.5508>; else goto <D.5509>;
  <D.5508>:
  {
    size_t sizebits;
    struct malloc_tree_chunk * rst;

    if (idx != 31) goto <D.5511>; else goto <D.5512>;
    <D.5511>:
    D.5513 = idx >> 1;
    D.5514 = 25 - D.5513;
    iftmp.19 = (int) D.5514;
    goto <D.5515>;
    <D.5512>:
    iftmp.19 = 0;
    <D.5515>:
    sizebits = nb << iftmp.19;
    rst = 0B;
    <D.5008>:
    {
      struct malloc_tree_chunk * rt;
      size_t trem;

      D.5516 = t->head;
      D.5517 = D.5516 & 4294967292;
      trem = D.5517 - nb;
      if (trem < rsize) goto <D.5518>; else goto <D.5519>;
      <D.5518>:
      v = t;
      rsize = trem;
      if (rsize == 0) goto <D.5007>; else goto <D.5520>;
      <D.5520>:
      <D.5519>:
      rt = t->child[1];
      D.5521 = sizebits >> 31;
      t = t->child[D.5521];
      if (rt != 0B) goto <D.5522>; else goto <D.5523>;
      <D.5522>:
      if (rt != t) goto <D.5524>; else goto <D.5525>;
      <D.5524>:
      rst = rt;
      <D.5525>:
      <D.5523>:
      if (t == 0B) goto <D.5526>; else goto <D.5527>;
      <D.5526>:
      t = rst;
      goto <D.5007>;
      <D.5527>:
      sizebits = sizebits << 1;
    }
    goto <D.5008>;
    <D.5007>:
  }
  <D.5509>:
  if (t == 0B) goto <D.5528>; else goto <D.5529>;
  <D.5528>:
  if (v == 0B) goto <D.5530>; else goto <D.5531>;
  <D.5530>:
  {
    binmap_t leftbits;

    idx.20 = (int) idx;
    D.5533 = 1 << idx.20;
    D.5534 = D.5533 << 1;
    idx.20 = (int) idx;
    D.5533 = 1 << idx.20;
    D.5534 = D.5533 << 1;
    D.5535 = -D.5534;
    D.5536 = D.5534 | D.5535;
    D.5537 = m->treemap;
    leftbits = D.5536 & D.5537;
    if (leftbits != 0) goto <D.5538>; else goto <D.5539>;
    <D.5538>:
    {
      bindex_t i;
      binmap_t leastbit;

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

        Y = leastbit + 4294967295;
        D.5541 = Y >> 12;
        K = D.5541 & 16;
        N = K;
        K.21 = (int) K;
        Y = Y >> K.21;
        D.5543 = Y >> 5;
        K = D.5543 & 8;
        K.22 = K;
        N = K.22 + N;
        K.21 = (int) K;
        Y = Y >> K.21;
        D.5545 = Y >> 2;
        K = D.5545 & 4;
        K.23 = K;
        N = K.23 + N;
        K.21 = (int) K;
        Y = Y >> K.21;
        D.5547 = Y >> 1;
        K = D.5547 & 2;
        K.24 = K;
        N = K.24 + N;
        K.21 = (int) K;
        Y = Y >> K.21;
        D.5547 = Y >> 1;
        K = D.5547 & 1;
        K.25 = K;
        N = K.25 + N;
        K.21 = (int) K;
        Y = Y >> K.21;
        i = N + Y;
      }
      t = m->treebins[i];
    }
    <D.5539>:
  }
  <D.5531>:
  <D.5529>:
  goto <D.5017>;
  <D.5016>:
  {
    size_t trem;

    D.5516 = t->head;
    D.5517 = D.5516 & 4294967292;
    trem = D.5517 - nb;
    if (trem < rsize) goto <D.5550>; else goto <D.5551>;
    <D.5550>:
    rsize = trem;
    v = t;
    <D.5551>:
    D.5553 = t->child[0];
    if (D.5553 != 0B) goto <D.5554>; else goto <D.5555>;
    <D.5554>:
    iftmp.26 = t->child[0];
    goto <D.5556>;
    <D.5555>:
    iftmp.26 = t->child[1];
    <D.5556>:
    t = iftmp.26;
  }
  <D.5017>:
  if (t != 0B) goto <D.5016>; else goto <D.5018>;
  <D.5018>:
  if (v != 0B) goto <D.5557>; else goto <D.5558>;
  <D.5557>:
  D.5559 = m->dvsize;
  D.5560 = D.5559 - nb;
  if (D.5560 > rsize) goto <D.5561>; else goto <D.5562>;
  <D.5561>:
  D.5563 = m->least_addr;
  D.5564 = D.5563 <= v;
  D.5565 = (long int) D.5564;
  D.5566 = __builtin_expect (D.5565, 1);
  if (D.5566 != 0) goto <D.5567>; else goto <D.5568>;
  <D.5567>:
  {
    struct malloc_chunk * r;

    r = v + nb;
    D.5569 = v < r;
    D.5570 = (long int) D.5569;
    D.5571 = __builtin_expect (D.5570, 1);
    if (D.5571 != 0) goto <D.5572>; else goto <D.5573>;
    <D.5572>:
    {
      struct malloc_tree_chunk * XP;
      struct malloc_tree_chunk * R;

      XP = v->parent;
      D.5574 = v->bk;
      if (D.5574 != v) goto <D.5575>; else goto <D.5576>;
      <D.5575>:
      {
        struct malloc_tree_chunk * F;

        F = v->fd;
        R = v->bk;
        D.5563 = m->least_addr;
        D.5577 = D.5563 <= F;
        D.5578 = (long int) D.5577;
        D.5579 = __builtin_expect (D.5578, 1);
        if (D.5579 != 0) goto <D.5580>; else goto <D.5581>;
        <D.5580>:
        F->bk = R;
        R->fd = F;
        goto <D.5582>;
        <D.5581>:
        abort ();
        <D.5582>:
      }
      goto <D.5583>;
      <D.5576>:
      {
        struct malloc_tree_chunk * * RP;

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

          goto <D.5026>;
          <D.5025>:
          RP = CP;
          R = *RP;
          <D.5026>:
          CP = &R->child[1];
          D.5587 = *CP;
          if (D.5587 != 0B) goto <D.5025>; else goto <D.5588>;
          <D.5588>:
          CP = &R->child[0];
          D.5587 = *CP;
          if (D.5587 != 0B) goto <D.5025>; else goto <D.5027>;
          <D.5027>:
          D.5563 = m->least_addr;
          D.5589 = D.5563 <= RP;
          D.5590 = (long int) D.5589;
          D.5591 = __builtin_expect (D.5590, 1);
          if (D.5591 != 0) goto <D.5592>; else goto <D.5593>;
          <D.5592>:
          *RP = 0B;
          goto <D.5594>;
          <D.5593>:
          abort ();
          <D.5594>:
        }
        <D.5585>:
      }
      <D.5583>:
      if (XP != 0B) goto <D.5595>; else goto <D.5596>;
      <D.5595>:
      {
        struct malloc_tree_chunk * * H;

        D.5597 = v->index;
        H = &m->treebins[D.5597];
        D.5598 = *H;
        if (D.5598 == v) goto <D.5599>; else goto <D.5600>;
        <D.5599>:
        *H = R;
        D.5598 = *H;
        if (D.5598 == 0B) goto <D.5601>; else goto <D.5602>;
        <D.5601>:
        D.5537 = m->treemap;
        D.5597 = v->index;
        D.5603 = (int) D.5597;
        D.5604 = 1 << D.5603;
        D.5605 = ~D.5604;
        D.5606 = D.5537 & D.5605;
        m->treemap = D.5606;
        <D.5602>:
        goto <D.5607>;
        <D.5600>:
        D.5563 = m->least_addr;
        D.5608 = D.5563 <= XP;
        D.5609 = (long int) D.5608;
        D.5610 = __builtin_expect (D.5609, 1);
        if (D.5610 != 0) goto <D.5611>; else goto <D.5612>;
        <D.5611>:
        D.5613 = XP->child[0];
        if (D.5613 == v) goto <D.5614>; else goto <D.5615>;
        <D.5614>:
        XP->child[0] = R;
        goto <D.5616>;
        <D.5615>:
        XP->child[1] = R;
        <D.5616>:
        goto <D.5617>;
        <D.5612>:
        abort ();
        <D.5617>:
        <D.5607>:
        if (R != 0B) goto <D.5618>; else goto <D.5619>;
        <D.5618>:
        D.5563 = m->least_addr;
        D.5620 = D.5563 <= R;
        D.5621 = (long int) D.5620;
        D.5622 = __builtin_expect (D.5621, 1);
        if (D.5622 != 0) goto <D.5623>; else goto <D.5624>;
        <D.5623>:
        {
          struct malloc_tree_chunk * C0;
          struct malloc_tree_chunk * C1;

          R->parent = XP;
          C0 = v->child[0];
          if (C0 != 0B) goto <D.5625>; else goto <D.5626>;
          <D.5625>:
          D.5563 = m->least_addr;
          D.5627 = D.5563 <= C0;
          D.5628 = (long int) D.5627;
          D.5629 = __builtin_expect (D.5628, 1);
          if (D.5629 != 0) goto <D.5630>; else goto <D.5631>;
          <D.5630>:
          R->child[0] = C0;
          C0->parent = R;
          goto <D.5632>;
          <D.5631>:
          abort ();
          <D.5632>:
          <D.5626>:
          C1 = v->child[1];
          if (C1 != 0B) goto <D.5633>; else goto <D.5634>;
          <D.5633>:
          D.5563 = m->least_addr;
          D.5635 = D.5563 <= C1;
          D.5636 = (long int) D.5635;
          D.5637 = __builtin_expect (D.5636, 1);
          if (D.5637 != 0) goto <D.5638>; else goto <D.5639>;
          <D.5638>:
          R->child[1] = C1;
          C1->parent = R;
          goto <D.5640>;
          <D.5639>:
          abort ();
          <D.5640>:
          <D.5634>:
        }
        goto <D.5641>;
        <D.5624>:
        abort ();
        <D.5641>:
        <D.5619>:
      }
      <D.5596>:
    }
    if (rsize <= 15) goto <D.5642>; else goto <D.5643>;
    <D.5642>:
    D.5644 = rsize + nb;
    D.5645 = D.5644 | 3;
    v->head = D.5645;
    D.5644 = rsize + nb;
    D.5646 = v + D.5644;
    D.5644 = rsize + nb;
    D.5646 = v + D.5644;
    D.5647 = D.5646->head;
    D.5648 = D.5647 | 1;
    D.5646->head = D.5648;
    goto <D.5649>;
    <D.5643>:
    D.5650 = nb | 3;
    v->head = D.5650;
    D.5651 = rsize | 1;
    r->head = D.5651;
    D.5652 = r + rsize;
    D.5652->prev_foot = rsize;
    D.5653 = rsize >> 3;
    if (D.5653 <= 31) goto <D.5654>; else goto <D.5655>;
    <D.5654>:
    {
      bindex_t I;
      struct malloc_chunk * B;
      struct malloc_chunk * F;

      I = rsize >> 3;
      D.5656 = I << 1;
      B = &m->smallbins[D.5656];
      F = B;
      D.5657 = m->smallmap;
      I.27 = (int) I;
      D.5659 = 1 << I.27;
      D.5660 = D.5657 & D.5659;
      if (D.5660 == 0) goto <D.5661>; else goto <D.5662>;
      <D.5661>:
      D.5657 = m->smallmap;
      I.27 = (int) I;
      D.5659 = 1 << I.27;
      D.5663 = D.5657 | D.5659;
      m->smallmap = D.5663;
      goto <D.5664>;
      <D.5662>:
      D.5665 = B->fd;
      D.5563 = m->least_addr;
      D.5666 = D.5665 >= D.5563;
      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>:
      F = B->fd;
      goto <D.5671>;
      <D.5670>:
      abort ();
      <D.5671>:
      <D.5664>:
      B->fd = r;
      F->bk = r;
      r->fd = F;
      r->bk = B;
    }
    goto <D.5672>;
    <D.5655>:
    {
      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.5673>; else goto <D.5674>;
          <D.5673>:
          I = 0;
          goto <D.5675>;
          <D.5674>:
          if (X > 65535) goto <D.5676>; else goto <D.5677>;
          <D.5676>:
          I = 31;
          goto <D.5678>;
          <D.5677>:
          {
            unsigned int Y;
            unsigned int N;
            unsigned int K;

            Y = X;
            D.5679 = Y + 4294967040;
            D.5680 = D.5679 >> 16;
            N = D.5680 & 8;
            N.28 = (int) N;
            Y = Y << N.28;
            D.5682 = Y + 4294963200;
            D.5683 = D.5682 >> 16;
            K = D.5683 & 4;
            N = N + K;
            K.29 = (int) K;
            Y = Y << K.29;
            D.5685 = Y + 4294950912;
            D.5686 = D.5685 >> 16;
            K = D.5686 & 2;
            K.30 = K;
            N = K.30 + N;
            K.29 = (int) K;
            Y = Y << K.29;
            D.5688 = Y >> 15;
            D.5689 = D.5688 - N;
            K = D.5689 + 14;
            D.5690 = K << 1;
            D.5691 = K + 7;
            D.5692 = (int) D.5691;
            D.5693 = rsize >> D.5692;
            D.5694 = D.5693 & 1;
            I = D.5690 + D.5694;
          }
          <D.5678>:
          <D.5675>:
        }
        H = &m->treebins[I];
        TP->index = I;
        TP->child[1] = 0B;
        D.5695 = TP->child[1];
        TP->child[0] = D.5695;
        D.5537 = m->treemap;
        I.31 = (int) I;
        D.5697 = 1 << I.31;
        D.5698 = D.5537 & D.5697;
        if (D.5698 == 0) goto <D.5699>; else goto <D.5700>;
        <D.5699>:
        D.5537 = m->treemap;
        I.31 = (int) I;
        D.5697 = 1 << I.31;
        D.5701 = D.5537 | D.5697;
        m->treemap = D.5701;
        *H = TP;
        TP->parent = H;
        TP->bk = TP;
        D.5702 = TP->bk;
        TP->fd = D.5702;
        goto <D.5703>;
        <D.5700>:
        {
          struct malloc_tree_chunk * T;
          size_t K;

          T = *H;
          if (I != 31) goto <D.5705>; else goto <D.5706>;
          <D.5705>:
          D.5707 = I >> 1;
          D.5708 = 25 - D.5707;
          iftmp.32 = (int) D.5708;
          goto <D.5709>;
          <D.5706>:
          iftmp.32 = 0;
          <D.5709>:
          K = rsize << iftmp.32;
          <D.5046>:
          D.5710 = T->head;
          D.5711 = D.5710 & 4294967292;
          if (D.5711 != rsize) goto <D.5712>; else goto <D.5713>;
          <D.5712>:
          {
            struct malloc_tree_chunk * * C;

            D.5714 = K >> 31;
            C = &T->child[D.5714];
            K = K << 1;
            D.5715 = *C;
            if (D.5715 != 0B) goto <D.5716>; else goto <D.5717>;
            <D.5716>:
            T = *C;
            goto <D.5718>;
            <D.5717>:
            D.5563 = m->least_addr;
            D.5719 = D.5563 <= C;
            D.5720 = (long int) D.5719;
            D.5721 = __builtin_expect (D.5720, 1);
            if (D.5721 != 0) goto <D.5722>; else goto <D.5723>;
            <D.5722>:
            *C = TP;
            TP->parent = T;
            TP->bk = TP;
            D.5702 = TP->bk;
            TP->fd = D.5702;
            goto <D.5044>;
            <D.5723>:
            abort ();
            <D.5718>:
          }
          goto <D.5724>;
          <D.5713>:
          {
            struct malloc_tree_chunk * F;

            F = T->fd;
            D.5563 = m->least_addr;
            D.5726 = D.5563 <= T;
            D.5727 = (long int) D.5726;
            D.5728 = __builtin_expect (D.5727, 1);
            if (D.5728 != 0) goto <D.5729>; else goto <D.5725>;
            <D.5729>:
            D.5563 = m->least_addr;
            D.5730 = D.5563 <= F;
            D.5731 = (long int) D.5730;
            D.5732 = __builtin_expect (D.5731, 1);
            if (D.5732 != 0) goto <D.5733>; else goto <D.5725>;
            <D.5733>:
            F->bk = TP;
            D.5734 = F->bk;
            T->fd = D.5734;
            TP->fd = F;
            TP->bk = T;
            TP->parent = 0B;
            goto <D.5044>;
            <D.5725>:
            abort ();
          }
          <D.5724>:
          goto <D.5046>;
          <D.5044>:
        }
        <D.5703>:
      }
    }
    <D.5672>:
    <D.5649>:
    D.5735 = v + 8;
    return D.5735;
    <D.5573>:
  }
  <D.5568>:
  abort ();
  <D.5562>:
  <D.5558>:
  D.5735 = 0B;
  return D.5735;
}


sys_alloc (struct malloc_state * m, size_t nb)
{
  unsigned int D.5737;
  unsigned int D.5738;
  unsigned int D.5741;
  void * D.5746;
  struct malloc_segment * iftmp.33;
  struct malloc_chunk * D.5750;
  unsigned int D.5758;
  unsigned int D.5759;
  unsigned int D.5760;
  unsigned int D.5761;
  unsigned int D.5762;
  unsigned int D.5763;
  unsigned int base.34;
  unsigned int D.5765;
  unsigned int D.5768;
  unsigned int D.5769;
  unsigned int D.5770;
  unsigned int D.5771;
  unsigned int D.5777;
  unsigned int D.5778;
  unsigned int D.5779;
  unsigned int D.5780;
  char * D.5783;
  unsigned int D.5784;
  char * D.5785;
  unsigned int D.5794;
  unsigned int D.5797;
  unsigned int D.5798;
  unsigned int D.5799;
  unsigned int D.5808;
  unsigned int D.5811;
  int end.35;
  int br.36;
  int D.5828;
  unsigned int D.5829;
  unsigned int D.5834;
  unsigned int D.5835;
  unsigned int D.5836;
  char * D.5841;
  unsigned int D.5842;
  unsigned int D.5845;
  struct malloc_chunk * D.5847;
  unsigned int D.5848;
  sizetype D.5849;
  sizetype D.5850;
  char * D.5851;
  int D.5852;
  int mn.37;
  int D.5854;
  unsigned int D.5855;
  unsigned int D.5856;
  char * D.5859;
  unsigned int D.5860;
  char * D.5861;
  unsigned int D.5865;
  unsigned int D.5866;
  unsigned int D.5868;
  unsigned int D.5872;
  unsigned int D.5873;
  unsigned int D.5883;
  struct malloc_chunk * D.5884;
  unsigned int D.5885;
  unsigned int D.5886;
  int * D.5887;
  char * tbase;
  size_t tsize;
  flag_t mmap_flag;

  tbase = 4294967295B;
  tsize = 0;
  mmap_flag = 0;
  init_mparams ();
  D.5737 = m->mflags;
  D.5738 = D.5737 & 1;
  if (D.5738 != 0) goto <D.5739>; else goto <D.5740>;
  <D.5739>:
  D.5741 = mparams.mmap_threshold;
  if (D.5741 <= nb) goto <D.5742>; else goto <D.5743>;
  <D.5742>:
  {
    void * mem;

    mem = mmap_alloc (m, nb);
    if (mem != 0B) goto <D.5744>; else goto <D.5745>;
    <D.5744>:
    D.5746 = mem;
    return D.5746;
    <D.5745>:
  }
  <D.5743>:
  <D.5740>:
  if (0 != 0) goto <D.5747>; else goto <D.5748>;
  <D.5747>:
  {
    char * br;
    struct malloc_segment * ss;
    size_t asize;

    br = 4294967295B;
    D.5750 = m->top;
    if (D.5750 != 0B) goto <D.5751>; else goto <D.5752>;
    <D.5751>:
    D.5750 = m->top;
    iftmp.33 = segment_holding (m, D.5750);
    goto <D.5753>;
    <D.5752>:
    iftmp.33 = 0B;
    <D.5753>:
    ss = iftmp.33;
    asize = 0;
    if (ss == 0B) goto <D.5754>; else goto <D.5755>;
    <D.5754>:
    {
      char * base;

      base = 4294967295B;
      if (base != 4294967295B) goto <D.5756>; else goto <D.5757>;
      <D.5756>:
      D.5758 = mparams.granularity;
      D.5759 = D.5758 + nb;
      D.5760 = D.5759 + 41;
      D.5758 = mparams.granularity;
      D.5761 = -D.5758;
      asize = D.5760 & D.5761;
      D.5762 = mparams.page_size;
      D.5763 = D.5762 + 4294967295;
      base.34 = (unsigned int) base;
      D.5765 = D.5763 & base.34;
      if (D.5765 != 0) goto <D.5766>; else goto <D.5767>;
      <D.5766>:
      D.5762 = mparams.page_size;
      base.34 = (unsigned int) base;
      D.5768 = D.5762 + base.34;
      D.5762 = mparams.page_size;
      D.5769 = -D.5762;
      D.5770 = D.5768 & D.5769;
      base.34 = (unsigned int) base;
      D.5771 = D.5770 - base.34;
      asize = D.5771 + asize;
      <D.5767>:
      if (asize <= 2147483646) goto <D.5772>; else goto <D.5773>;
      <D.5772>:
      br = 4294967295B;
      if (br == base) goto <D.5774>; else goto <D.5775>;
      <D.5774>:
      tbase = base;
      tsize = asize;
      <D.5775>:
      <D.5773>:
      <D.5757>:
    }
    goto <D.5776>;
    <D.5755>:
    D.5777 = m->topsize;
    D.5778 = nb - D.5777;
    D.5758 = mparams.granularity;
    D.5779 = D.5778 + D.5758;
    D.5780 = D.5779 + 41;
    D.5758 = mparams.granularity;
    D.5761 = -D.5758;
    asize = D.5780 & D.5761;
    if (asize <= 2147483646) goto <D.5781>; else goto <D.5782>;
    <D.5781>:
    br = 4294967295B;
    D.5783 = ss->base;
    D.5784 = ss->size;
    D.5785 = D.5783 + D.5784;
    if (br == D.5785) goto <D.5786>; else goto <D.5787>;
    <D.5786>:
    tbase = br;
    tsize = asize;
    <D.5787>:
    <D.5782>:
    <D.5776>:
    if (tbase == 4294967295B) goto <D.5788>; else goto <D.5789>;
    <D.5788>:
    if (br != 4294967295B) goto <D.5790>; else goto <D.5791>;
    <D.5790>:
    if (asize <= 2147483646) goto <D.5792>; else goto <D.5793>;
    <D.5792>:
    D.5794 = nb + 41;
    if (D.5794 > asize) goto <D.5795>; else goto <D.5796>;
    <D.5795>:
    {
      size_t esize;

      D.5797 = nb - asize;
      D.5758 = mparams.granularity;
      D.5798 = D.5797 + D.5758;
      D.5799 = D.5798 + 41;
      D.5758 = mparams.granularity;
      D.5761 = -D.5758;
      esize = D.5799 & D.5761;
      if (esize <= 2147483646) goto <D.5800>; else goto <D.5801>;
      <D.5800>:
      {
        char * end;

        end = 4294967295B;
        if (end != 4294967295B) goto <D.5802>; else goto <D.5803>;
        <D.5802>:
        asize = asize + esize;
        goto <D.5804>;
        <D.5803>:
        br = 4294967295B;
        <D.5804>:
      }
      <D.5801>:
    }
    <D.5796>:
    <D.5793>:
    <D.5791>:
    if (br != 4294967295B) goto <D.5805>; else goto <D.5806>;
    <D.5805>:
    tbase = br;
    tsize = asize;
    goto <D.5807>;
    <D.5806>:
    D.5737 = m->mflags;
    D.5808 = D.5737 | 4;
    m->mflags = D.5808;
    <D.5807>:
    <D.5789>:
  }
  <D.5748>:
  if (tbase == 4294967295B) goto <D.5809>; else goto <D.5810>;
  <D.5809>:
  {
    size_t req;
    size_t rsize;

    req = nb + 41;
    D.5758 = mparams.granularity;
    D.5811 = D.5758 + req;
    D.5758 = mparams.granularity;
    D.5761 = -D.5758;
    rsize = D.5811 & D.5761;
    if (rsize > nb) goto <D.5812>; else goto <D.5813>;
    <D.5812>:
    {
      char * mp;

      mp = mmap (0B, rsize, 7, 2050, -1, 0);
      if (mp != 4294967295B) goto <D.5814>; else goto <D.5815>;
      <D.5814>:
      tbase = mp;
      tsize = rsize;
      mmap_flag = 1;
      <D.5815>:
    }
    <D.5813>:
  }
  <D.5810>:
  if (0 != 0) goto <D.5816>; else goto <D.5817>;
  <D.5816>:
  {
    size_t asize;

    D.5758 = mparams.granularity;
    D.5759 = D.5758 + nb;
    D.5760 = D.5759 + 41;
    D.5758 = mparams.granularity;
    D.5761 = -D.5758;
    asize = D.5760 & D.5761;
    if (asize <= 2147483646) goto <D.5818>; else goto <D.5819>;
    <D.5818>:
    {
      char * br;
      char * end;

      br = 4294967295B;
      end = 4294967295B;
      br = 4294967295B;
      end = 4294967295B;
      if (br != 4294967295B) goto <D.5820>; else goto <D.5821>;
      <D.5820>:
      if (end != 4294967295B) goto <D.5822>; else goto <D.5823>;
      <D.5822>:
      if (br < end) goto <D.5824>; else goto <D.5825>;
      <D.5824>:
      {
        size_t ssize;

        end.35 = (int) end;
        br.36 = (int) br;
        D.5828 = end.35 - br.36;
        ssize = (size_t) D.5828;
        D.5829 = nb + 40;
        if (D.5829 < ssize) goto <D.5830>; else goto <D.5831>;
        <D.5830>:
        tbase = br;
        tsize = ssize;
        <D.5831>:
      }
      <D.5825>:
      <D.5823>:
      <D.5821>:
    }
    <D.5819>:
  }
  <D.5817>:
  if (tbase != 4294967295B) goto <D.5832>; else goto <D.5833>;
  <D.5832>:
  D.5834 = m->footprint;
  D.5835 = D.5834 + tsize;
  m->footprint = D.5835;
  D.5834 = m->footprint;
  D.5836 = m->max_footprint;
  if (D.5834 > D.5836) goto <D.5837>; else goto <D.5838>;
  <D.5837>:
  D.5834 = m->footprint;
  m->max_footprint = D.5834;
  <D.5838>:
  D.5750 = m->top;
  if (D.5750 == 0B) goto <D.5839>; else goto <D.5840>;
  <D.5839>:
  m->least_addr = tbase;
  D.5841 = m->least_addr;
  m->seg.base = D.5841;
  m->seg.size = tsize;
  m->seg.sflags = mmap_flag;
  D.5842 = mparams.magic;
  m->magic = D.5842;
  init_bins (m);
  if (m == &_gm_) goto <D.5843>; else goto <D.5844>;
  <D.5843>:
  D.5845 = tsize + 4294967256;
  init_top (m, tbase, D.5845);
  goto <D.5846>;
  <D.5844>:
  {
    struct malloc_chunk * mn;

    D.5847 = m + 4294967288;
    D.5848 = D.5847->head;
    D.5849 = D.5848 & 4294967292;
    D.5850 = D.5849 + 4294967288;
    mn = m + D.5850;
    D.5851 = tbase + tsize;
    D.5852 = (int) D.5851;
    mn.37 = (int) mn;
    D.5854 = D.5852 - mn.37;
    D.5855 = (unsigned int) D.5854;
    D.5856 = D.5855 + 4294967256;
    init_top (m, mn, D.5856);
  }
  <D.5846>:
  goto <D.5857>;
  <D.5840>:
  {
    struct malloc_segment * sp;

    sp = &m->seg;
    goto <D.4932>;
    <D.4931>:
    sp = sp->next;
    <D.4932>:
    if (sp != 0B) goto <D.5858>; else goto <D.4933>;
    <D.5858>:
    D.5859 = sp->base;
    D.5860 = sp->size;
    D.5861 = D.5859 + D.5860;
    if (D.5861 != tbase) goto <D.4931>; else goto <D.4933>;
    <D.4933>:
    if (sp != 0B) goto <D.5864>; else goto <D.5862>;
    <D.5864>:
    D.5865 = sp->sflags;
    D.5866 = D.5865 & 8;
    if (D.5866 == 0) goto <D.5867>; else goto <D.5862>;
    <D.5867>:
    D.5865 = sp->sflags;
    D.5868 = D.5865 & 1;
    if (D.5868 == mmap_flag) goto <D.5869>; else goto <D.5862>;
    <D.5869>:
    D.5750 = m->top;
    D.5859 = sp->base;
    if (D.5750 >= D.5859) goto <D.5870>; else goto <D.5862>;
    <D.5870>:
    D.5750 = m->top;
    D.5859 = sp->base;
    D.5860 = sp->size;
    D.5861 = D.5859 + D.5860;
    if (D.5750 < D.5861) goto <D.5871>; else goto <D.5862>;
    <D.5871>:
    D.5860 = sp->size;
    D.5872 = D.5860 + tsize;
    sp->size = D.5872;
    D.5750 = m->top;
    D.5777 = m->topsize;
    D.5873 = D.5777 + tsize;
    init_top (m, D.5750, D.5873);
    goto <D.5863>;
    <D.5862>:
    D.5841 = m->least_addr;
    if (D.5841 > tbase) goto <D.5874>; else goto <D.5875>;
    <D.5874>:
    m->least_addr = tbase;
    <D.5875>:
    sp = &m->seg;
    goto <D.4935>;
    <D.4934>:
    sp = sp->next;
    <D.4935>:
    if (sp != 0B) goto <D.5876>; else goto <D.4936>;
    <D.5876>:
    D.5859 = sp->base;
    D.5851 = tbase + tsize;
    if (D.5859 != D.5851) goto <D.4934>; else goto <D.4936>;
    <D.4936>:
    if (sp != 0B) goto <D.5878>; else goto <D.5877>;
    <D.5878>:
    D.5865 = sp->sflags;
    D.5866 = D.5865 & 8;
    if (D.5866 == 0) goto <D.5879>; else goto <D.5877>;
    <D.5879>:
    D.5865 = sp->sflags;
    D.5868 = D.5865 & 1;
    if (D.5868 == mmap_flag) goto <D.5880>; else goto <D.5877>;
    <D.5880>:
    {
      char * oldbase;

      oldbase = sp->base;
      sp->base = tbase;
      D.5860 = sp->size;
      D.5872 = D.5860 + tsize;
      sp->size = D.5872;
      D.5746 = prepend_alloc (m, tbase, oldbase, nb);
      return D.5746;
    }
    <D.5877>:
    add_segment (m, tbase, tsize, mmap_flag);
    <D.5863>:
  }
  <D.5857>:
  D.5777 = m->topsize;
  if (D.5777 > nb) goto <D.5881>; else goto <D.5882>;
  <D.5881>:
  {
    size_t rsize;
    struct malloc_chunk * p;
    struct malloc_chunk * r;

    D.5777 = m->topsize;
    D.5883 = D.5777 - nb;
    m->topsize = D.5883;
    rsize = m->topsize;
    p = m->top;
    D.5884 = p + nb;
    m->top = D.5884;
    r = m->top;
    D.5885 = rsize | 1;
    r->head = D.5885;
    D.5886 = nb | 3;
    p->head = D.5886;
    D.5746 = p + 8;
    return D.5746;
  }
  <D.5882>:
  <D.5833>:
  D.5887 = __errno_location ();
  *D.5887 = 12;
  D.5746 = 0B;
  return D.5746;
}


mmap_alloc (struct malloc_state * m, size_t nb)
{
  unsigned int D.5889;
  unsigned int D.5890;
  unsigned int D.5891;
  unsigned int D.5892;
  unsigned int iftmp.38;
  void * D.5898;
  unsigned int D.5899;
  unsigned int D.5900;
  unsigned int D.5903;
  unsigned int D.5905;
  unsigned int D.5906;
  unsigned int D.5907;
  struct malloc_chunk * D.5908;
  sizetype D.5909;
  struct malloc_chunk * D.5910;
  char * D.5911;
  unsigned int D.5914;
  unsigned int D.5915;
  unsigned int D.5916;
  void * D.5919;
  size_t mmsize;

  D.5889 = mparams.granularity;
  D.5890 = D.5889 + nb;
  D.5891 = D.5890 + 31;
  D.5889 = mparams.granularity;
  D.5892 = -D.5889;
  mmsize = D.5891 & D.5892;
  if (mmsize > nb) goto <D.5893>; else goto <D.5894>;
  <D.5893>:
  {
    char * mm;

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

      D.5898 = mm + 8;
      D.5899 = (unsigned int) D.5898;
      D.5900 = D.5899 & 7;
      if (D.5900 != 0) goto <D.5901>; else goto <D.5902>;
      <D.5901>:
      D.5898 = mm + 8;
      D.5899 = (unsigned int) D.5898;
      D.5903 = -D.5899;
      iftmp.38 = D.5903 & 7;
      goto <D.5904>;
      <D.5902>:
      iftmp.38 = 0;
      <D.5904>:
      offset = iftmp.38;
      D.5905 = mmsize - offset;
      psize = D.5905 + 4294967280;
      p = mm + offset;
      D.5906 = offset | 1;
      p->prev_foot = D.5906;
      D.5907 = psize | 2;
      p->head = D.5907;
      D.5908 = p + psize;
      D.5908->head = 7;
      D.5909 = psize + 4;
      D.5910 = p + D.5909;
      D.5910->head = 0;
      D.5911 = m->least_addr;
      if (D.5911 > mm) goto <D.5912>; else goto <D.5913>;
      <D.5912>:
      m->least_addr = mm;
      <D.5913>:
      D.5914 = m->footprint;
      D.5915 = D.5914 + mmsize;
      m->footprint = D.5915;
      D.5914 = m->footprint;
      D.5916 = m->max_footprint;
      if (D.5914 > D.5916) goto <D.5917>; else goto <D.5918>;
      <D.5917>:
      D.5914 = m->footprint;
      m->max_footprint = D.5914;
      <D.5918>:
      D.5919 = p + 8;
      return D.5919;
    }
    <D.5896>:
  }
  <D.5894>:
  D.5919 = 0B;
  return D.5919;
}


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

  i = 0;
  goto <D.4820>;
  <D.4819>:
  {
    struct malloc_chunk * bin;

    D.5921 = i << 1;
    bin = &m->smallbins[D.5921];
    bin->bk = bin;
    D.5922 = bin->bk;
    bin->fd = D.5922;
  }
  i = i + 1;
  <D.4820>:
  if (i <= 31) goto <D.4819>; else goto <D.4821>;
  <D.4821>:
}


init_top (struct malloc_state * m, struct malloc_chunk * p, size_t psize)
{
  unsigned int iftmp.39;
  void * D.5924;
  unsigned int D.5925;
  unsigned int D.5926;
  unsigned int D.5929;
  unsigned int D.5931;
  struct malloc_chunk * D.5932;
  unsigned int D.5933;
  size_t offset;

  D.5924 = p + 8;
  D.5925 = (unsigned int) D.5924;
  D.5926 = D.5925 & 7;
  if (D.5926 != 0) goto <D.5927>; else goto <D.5928>;
  <D.5927>:
  D.5924 = p + 8;
  D.5925 = (unsigned int) D.5924;
  D.5929 = -D.5925;
  iftmp.39 = D.5929 & 7;
  goto <D.5930>;
  <D.5928>:
  iftmp.39 = 0;
  <D.5930>:
  offset = iftmp.39;
  p = p + offset;
  psize = psize - offset;
  m->top = p;
  m->topsize = psize;
  D.5931 = psize | 1;
  p->head = D.5931;
  D.5932 = p + psize;
  D.5932->head = 40;
  D.5933 = mparams.trim_threshold;
  m->trim_check = D.5933;
}


prepend_alloc (struct malloc_state * m, char * newbase, char * oldbase, size_t nb)
{
  sizetype iftmp.40;
  void * D.5935;
  unsigned int D.5936;
  unsigned int D.5937;
  unsigned int D.5940;
  sizetype iftmp.41;
  void * D.5943;
  unsigned int D.5944;
  unsigned int D.5945;
  unsigned int D.5948;
  int oldfirst.42;
  int p.43;
  int D.5952;
  unsigned int D.5953;
  struct malloc_chunk * D.5954;
  unsigned int D.5957;
  unsigned int D.5958;
  unsigned int D.5959;
  struct malloc_chunk * D.5961;
  unsigned int D.5964;
  unsigned int D.5965;
  unsigned int D.5966;
  struct malloc_chunk * D.5967;
  unsigned int D.5969;
  unsigned int D.5970;
  unsigned int D.5973;
  unsigned int D.5978;
  int I.44;
  unsigned int D.5980;
  unsigned int D.5981;
  unsigned int D.5982;
  int iftmp.45;
  unsigned int D.5990;
  struct malloc_chunk * * D.5991;
  _Bool D.5992;
  long int D.5993;
  long int D.5994;
  char * D.5996;
  _Bool D.5997;
  long int D.5998;
  long int D.5999;
  int iftmp.46;
  _Bool D.6005;
  long int D.6006;
  long int D.6007;
  _Bool D.6009;
  long int D.6010;
  long int D.6011;
  struct malloc_tree_chunk * D.6014;
  _Bool D.6017;
  long int D.6018;
  long int D.6019;
  struct malloc_tree_chunk * D.6027;
  _Bool D.6029;
  long int D.6030;
  long int D.6031;
  unsigned int D.6037;
  struct malloc_tree_chunk * D.6038;
  unsigned int D.6043;
  int D.6044;
  unsigned int D.6045;
  unsigned int D.6046;
  unsigned int D.6047;
  _Bool D.6049;
  long int D.6050;
  long int D.6051;
  struct malloc_tree_chunk * D.6054;
  _Bool D.6061;
  long int D.6062;
  long int D.6063;
  _Bool D.6068;
  long int D.6069;
  long int D.6070;
  _Bool D.6076;
  long int D.6077;
  long int D.6078;
  unsigned int D.6083;
  unsigned int D.6084;
  struct malloc_chunk * D.6085;
  unsigned int D.6086;
  unsigned int D.6089;
  int I.47;
  unsigned int D.6091;
  unsigned int D.6092;
  unsigned int D.6095;
  struct malloc_chunk * D.6097;
  _Bool D.6098;
  long int D.6099;
  long int D.6100;
  unsigned int D.6111;
  unsigned int D.6112;
  int N.48;
  unsigned int D.6114;
  unsigned int D.6115;
  int K.49;
  unsigned int D.6117;
  unsigned int D.6118;
  unsigned int K.50;
  unsigned int D.6120;
  unsigned int D.6121;
  unsigned int D.6122;
  unsigned int D.6123;
  int D.6124;
  unsigned int D.6125;
  unsigned int D.6126;
  struct malloc_tree_chunk * D.6127;
  int I.51;
  unsigned int D.6129;
  unsigned int D.6130;
  unsigned int D.6133;
  struct malloc_tree_chunk * D.6134;
  int iftmp.52;
  unsigned int D.6139;
  unsigned int D.6140;
  unsigned int D.6142;
  unsigned int D.6143;
  unsigned int D.6146;
  struct malloc_tree_chunk * D.6147;
  _Bool D.6151;
  long int D.6152;
  long int D.6153;
  _Bool D.6158;
  long int D.6159;
  long int D.6160;
  _Bool D.6162;
  long int D.6163;
  long int D.6164;
  struct malloc_tree_chunk * D.6166;
  void * D.6167;
  struct malloc_chunk * p;
  struct malloc_chunk * oldfirst;
  size_t psize;
  struct malloc_chunk * q;
  size_t qsize;

  D.5935 = newbase + 8;
  D.5936 = (unsigned int) D.5935;
  D.5937 = D.5936 & 7;
  if (D.5937 != 0) goto <D.5938>; else goto <D.5939>;
  <D.5938>:
  D.5935 = newbase + 8;
  D.5936 = (unsigned int) D.5935;
  D.5940 = -D.5936;
  iftmp.40 = D.5940 & 7;
  goto <D.5941>;
  <D.5939>:
  iftmp.40 = 0;
  <D.5941>:
  p = newbase + iftmp.40;
  D.5943 = oldbase + 8;
  D.5944 = (unsigned int) D.5943;
  D.5945 = D.5944 & 7;
  if (D.5945 != 0) goto <D.5946>; else goto <D.5947>;
  <D.5946>:
  D.5943 = oldbase + 8;
  D.5944 = (unsigned int) D.5943;
  D.5948 = -D.5944;
  iftmp.41 = D.5948 & 7;
  goto <D.5949>;
  <D.5947>:
  iftmp.41 = 0;
  <D.5949>:
  oldfirst = oldbase + iftmp.41;
  oldfirst.42 = (int) oldfirst;
  p.43 = (int) p;
  D.5952 = oldfirst.42 - p.43;
  psize = (size_t) D.5952;
  q = p + nb;
  qsize = psize - nb;
  D.5953 = nb | 3;
  p->head = D.5953;
  D.5954 = m->top;
  if (D.5954 == oldfirst) goto <D.5955>; else goto <D.5956>;
  <D.5955>:
  {
    size_t tsize;

    D.5957 = m->topsize;
    D.5958 = D.5957 + qsize;
    m->topsize = D.5958;
    tsize = m->topsize;
    m->top = q;
    D.5959 = tsize | 1;
    q->head = D.5959;
  }
  goto <D.5960>;
  <D.5956>:
  D.5961 = m->dv;
  if (D.5961 == oldfirst) goto <D.5962>; else goto <D.5963>;
  <D.5962>:
  {
    size_t dsize;

    D.5964 = m->dvsize;
    D.5965 = D.5964 + qsize;
    m->dvsize = D.5965;
    dsize = m->dvsize;
    m->dv = q;
    D.5966 = dsize | 1;
    q->head = D.5966;
    D.5967 = q + dsize;
    D.5967->prev_foot = dsize;
  }
  goto <D.5968>;
  <D.5963>:
  D.5969 = oldfirst->head;
  D.5970 = D.5969 & 2;
  if (D.5970 == 0) goto <D.5971>; else goto <D.5972>;
  <D.5971>:
  {
    size_t nsize;

    D.5969 = oldfirst->head;
    nsize = D.5969 & 4294967292;
    D.5973 = nsize >> 3;
    if (D.5973 <= 31) goto <D.5974>; else goto <D.5975>;
    <D.5974>:
    {
      struct malloc_chunk * F;
      struct malloc_chunk * B;
      bindex_t I;

      F = oldfirst->fd;
      B = oldfirst->bk;
      I = nsize >> 3;
      if (F == B) goto <D.5976>; else goto <D.5977>;
      <D.5976>:
      D.5978 = m->smallmap;
      I.44 = (int) I;
      D.5980 = 1 << I.44;
      D.5981 = ~D.5980;
      D.5982 = D.5978 & D.5981;
      m->smallmap = D.5982;
      goto <D.5983>;
      <D.5977>:
      D.5990 = I << 1;
      D.5991 = &m->smallbins[D.5990];
      D.5992 = D.5991 == F;
      D.5993 = (long int) D.5992;
      D.5994 = __builtin_expect (D.5993, 1);
      if (D.5994 != 0) goto <D.5987>; else goto <D.5995>;
      <D.5995>:
      D.5996 = m->least_addr;
      D.5997 = D.5996 <= F;
      D.5998 = (long int) D.5997;
      D.5999 = __builtin_expect (D.5998, 1);
      if (D.5999 != 0) goto <D.5987>; else goto <D.5988>;
      <D.5987>:
      iftmp.45 = 1;
      goto <D.5989>;
      <D.5988>:
      iftmp.45 = 0;
      <D.5989>:
      if (iftmp.45 != 0) goto <D.6000>; else goto <D.5984>;
      <D.6000>:
      D.5990 = I << 1;
      D.5991 = &m->smallbins[D.5990];
      D.6005 = D.5991 == B;
      D.6006 = (long int) D.6005;
      D.6007 = __builtin_expect (D.6006, 1);
      if (D.6007 != 0) goto <D.6002>; else goto <D.6008>;
      <D.6008>:
      D.5996 = m->least_addr;
      D.6009 = D.5996 <= B;
      D.6010 = (long int) D.6009;
      D.6011 = __builtin_expect (D.6010, 1);
      if (D.6011 != 0) goto <D.6002>; else goto <D.6003>;
      <D.6002>:
      iftmp.46 = 1;
      goto <D.6004>;
      <D.6003>:
      iftmp.46 = 0;
      <D.6004>:
      if (iftmp.46 != 0) goto <D.6012>; else goto <D.5984>;
      <D.6012>:
      F->bk = B;
      B->fd = F;
      goto <D.5985>;
      <D.5984>:
      abort ();
      <D.5985>:
      <D.5983>:
    }
    goto <D.6013>;
    <D.5975>:
    {
      struct malloc_tree_chunk * TP;

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

        XP = TP->parent;
        D.6014 = TP->bk;
        if (D.6014 != TP) goto <D.6015>; else goto <D.6016>;
        <D.6015>:
        {
          struct malloc_tree_chunk * F;

          F = TP->fd;
          R = TP->bk;
          D.5996 = m->least_addr;
          D.6017 = D.5996 <= F;
          D.6018 = (long int) D.6017;
          D.6019 = __builtin_expect (D.6018, 1);
          if (D.6019 != 0) goto <D.6020>; else goto <D.6021>;
          <D.6020>:
          F->bk = R;
          R->fd = F;
          goto <D.6022>;
          <D.6021>:
          abort ();
          <D.6022>:
        }
        goto <D.6023>;
        <D.6016>:
        {
          struct malloc_tree_chunk * * RP;

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

            goto <D.4846>;
            <D.4845>:
            RP = CP;
            R = *RP;
            <D.4846>:
            CP = &R->child[1];
            D.6027 = *CP;
            if (D.6027 != 0B) goto <D.4845>; else goto <D.6028>;
            <D.6028>:
            CP = &R->child[0];
            D.6027 = *CP;
            if (D.6027 != 0B) goto <D.4845>; else goto <D.4847>;
            <D.4847>:
            D.5996 = m->least_addr;
            D.6029 = D.5996 <= RP;
            D.6030 = (long int) D.6029;
            D.6031 = __builtin_expect (D.6030, 1);
            if (D.6031 != 0) goto <D.6032>; else goto <D.6033>;
            <D.6032>:
            *RP = 0B;
            goto <D.6034>;
            <D.6033>:
            abort ();
            <D.6034>:
          }
          <D.6025>:
        }
        <D.6023>:
        if (XP != 0B) goto <D.6035>; else goto <D.6036>;
        <D.6035>:
        {
          struct malloc_tree_chunk * * H;

          D.6037 = TP->index;
          H = &m->treebins[D.6037];
          D.6038 = *H;
          if (D.6038 == TP) goto <D.6039>; else goto <D.6040>;
          <D.6039>:
          *H = R;
          D.6038 = *H;
          if (D.6038 == 0B) goto <D.6041>; else goto <D.6042>;
          <D.6041>:
          D.6043 = m->treemap;
          D.6037 = TP->index;
          D.6044 = (int) D.6037;
          D.6045 = 1 << D.6044;
          D.6046 = ~D.6045;
          D.6047 = D.6043 & D.6046;
          m->treemap = D.6047;
          <D.6042>:
          goto <D.6048>;
          <D.6040>:
          D.5996 = m->least_addr;
          D.6049 = D.5996 <= XP;
          D.6050 = (long int) D.6049;
          D.6051 = __builtin_expect (D.6050, 1);
          if (D.6051 != 0) goto <D.6052>; else goto <D.6053>;
          <D.6052>:
          D.6054 = XP->child[0];
          if (D.6054 == TP) goto <D.6055>; else goto <D.6056>;
          <D.6055>:
          XP->child[0] = R;
          goto <D.6057>;
          <D.6056>:
          XP->child[1] = R;
          <D.6057>:
          goto <D.6058>;
          <D.6053>:
          abort ();
          <D.6058>:
          <D.6048>:
          if (R != 0B) goto <D.6059>; else goto <D.6060>;
          <D.6059>:
          D.5996 = m->least_addr;
          D.6061 = D.5996 <= R;
          D.6062 = (long int) D.6061;
          D.6063 = __builtin_expect (D.6062, 1);
          if (D.6063 != 0) goto <D.6064>; else goto <D.6065>;
          <D.6064>:
          {
            struct malloc_tree_chunk * C0;
            struct malloc_tree_chunk * C1;

            R->parent = XP;
            C0 = TP->child[0];
            if (C0 != 0B) goto <D.6066>; else goto <D.6067>;
            <D.6066>:
            D.5996 = m->least_addr;
            D.6068 = D.5996 <= C0;
            D.6069 = (long int) D.6068;
            D.6070 = __builtin_expect (D.6069, 1);
            if (D.6070 != 0) goto <D.6071>; else goto <D.6072>;
            <D.6071>:
            R->child[0] = C0;
            C0->parent = R;
            goto <D.6073>;
            <D.6072>:
            abort ();
            <D.6073>:
            <D.6067>:
            C1 = TP->child[1];
            if (C1 != 0B) goto <D.6074>; else goto <D.6075>;
            <D.6074>:
            D.5996 = m->least_addr;
            D.6076 = D.5996 <= C1;
            D.6077 = (long int) D.6076;
            D.6078 = __builtin_expect (D.6077, 1);
            if (D.6078 != 0) goto <D.6079>; else goto <D.6080>;
            <D.6079>:
            R->child[1] = C1;
            C1->parent = R;
            goto <D.6081>;
            <D.6080>:
            abort ();
            <D.6081>:
            <D.6075>:
          }
          goto <D.6082>;
          <D.6065>:
          abort ();
          <D.6082>:
          <D.6060>:
        }
        <D.6036>:
      }
    }
    <D.6013>:
    oldfirst = oldfirst + nsize;
    qsize = qsize + nsize;
  }
  <D.5972>:
  D.5969 = oldfirst->head;
  D.6083 = D.5969 & 4294967294;
  oldfirst->head = D.6083;
  D.6084 = qsize | 1;
  q->head = D.6084;
  D.6085 = q + qsize;
  D.6085->prev_foot = qsize;
  D.6086 = qsize >> 3;
  if (D.6086 <= 31) goto <D.6087>; else goto <D.6088>;
  <D.6087>:
  {
    bindex_t I;
    struct malloc_chunk * B;
    struct malloc_chunk * F;

    I = qsize >> 3;
    D.6089 = I << 1;
    B = &m->smallbins[D.6089];
    F = B;
    D.5978 = m->smallmap;
    I.47 = (int) I;
    D.6091 = 1 << I.47;
    D.6092 = D.5978 & D.6091;
    if (D.6092 == 0) goto <D.6093>; else goto <D.6094>;
    <D.6093>:
    D.5978 = m->smallmap;
    I.47 = (int) I;
    D.6091 = 1 << I.47;
    D.6095 = D.5978 | D.6091;
    m->smallmap = D.6095;
    goto <D.6096>;
    <D.6094>:
    D.6097 = B->fd;
    D.5996 = m->least_addr;
    D.6098 = D.6097 >= D.5996;
    D.6099 = (long int) D.6098;
    D.6100 = __builtin_expect (D.6099, 1);
    if (D.6100 != 0) goto <D.6101>; else goto <D.6102>;
    <D.6101>:
    F = B->fd;
    goto <D.6103>;
    <D.6102>:
    abort ();
    <D.6103>:
    <D.6096>:
    B->fd = q;
    F->bk = q;
    q->fd = F;
    q->bk = B;
  }
  goto <D.6104>;
  <D.6088>:
  {
    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.6105>; else goto <D.6106>;
        <D.6105>:
        I = 0;
        goto <D.6107>;
        <D.6106>:
        if (X > 65535) goto <D.6108>; else goto <D.6109>;
        <D.6108>:
        I = 31;
        goto <D.6110>;
        <D.6109>:
        {
          unsigned int Y;
          unsigned int N;
          unsigned int K;

          Y = X;
          D.6111 = Y + 4294967040;
          D.6112 = D.6111 >> 16;
          N = D.6112 & 8;
          N.48 = (int) N;
          Y = Y << N.48;
          D.6114 = Y + 4294963200;
          D.6115 = D.6114 >> 16;
          K = D.6115 & 4;
          N = N + K;
          K.49 = (int) K;
          Y = Y << K.49;
          D.6117 = Y + 4294950912;
          D.6118 = D.6117 >> 16;
          K = D.6118 & 2;
          K.50 = K;
          N = K.50 + N;
          K.49 = (int) K;
          Y = Y << K.49;
          D.6120 = Y >> 15;
          D.6121 = D.6120 - N;
          K = D.6121 + 14;
          D.6122 = K << 1;
          D.6123 = K + 7;
          D.6124 = (int) D.6123;
          D.6125 = qsize >> D.6124;
          D.6126 = D.6125 & 1;
          I = D.6122 + D.6126;
        }
        <D.6110>:
        <D.6107>:
      }
      H = &m->treebins[I];
      TP->index = I;
      TP->child[1] = 0B;
      D.6127 = TP->child[1];
      TP->child[0] = D.6127;
      D.6043 = m->treemap;
      I.51 = (int) I;
      D.6129 = 1 << I.51;
      D.6130 = D.6043 & D.6129;
      if (D.6130 == 0) goto <D.6131>; else goto <D.6132>;
      <D.6131>:
      D.6043 = m->treemap;
      I.51 = (int) I;
      D.6129 = 1 << I.51;
      D.6133 = D.6043 | D.6129;
      m->treemap = D.6133;
      *H = TP;
      TP->parent = H;
      TP->bk = TP;
      D.6134 = TP->bk;
      TP->fd = D.6134;
      goto <D.6135>;
      <D.6132>:
      {
        struct malloc_tree_chunk * T;
        size_t K;

        T = *H;
        if (I != 31) goto <D.6137>; else goto <D.6138>;
        <D.6137>:
        D.6139 = I >> 1;
        D.6140 = 25 - D.6139;
        iftmp.52 = (int) D.6140;
        goto <D.6141>;
        <D.6138>:
        iftmp.52 = 0;
        <D.6141>:
        K = qsize << iftmp.52;
        <D.4866>:
        D.6142 = T->head;
        D.6143 = D.6142 & 4294967292;
        if (D.6143 != qsize) goto <D.6144>; else goto <D.6145>;
        <D.6144>:
        {
          struct malloc_tree_chunk * * C;

          D.6146 = K >> 31;
          C = &T->child[D.6146];
          K = K << 1;
          D.6147 = *C;
          if (D.6147 != 0B) goto <D.6148>; else goto <D.6149>;
          <D.6148>:
          T = *C;
          goto <D.6150>;
          <D.6149>:
          D.5996 = m->least_addr;
          D.6151 = D.5996 <= C;
          D.6152 = (long int) D.6151;
          D.6153 = __builtin_expect (D.6152, 1);
          if (D.6153 != 0) goto <D.6154>; else goto <D.6155>;
          <D.6154>:
          *C = TP;
          TP->parent = T;
          TP->bk = TP;
          D.6134 = TP->bk;
          TP->fd = D.6134;
          goto <D.4864>;
          <D.6155>:
          abort ();
          <D.6150>:
        }
        goto <D.6156>;
        <D.6145>:
        {
          struct malloc_tree_chunk * F;

          F = T->fd;
          D.5996 = m->least_addr;
          D.6158 = D.5996 <= T;
          D.6159 = (long int) D.6158;
          D.6160 = __builtin_expect (D.6159, 1);
          if (D.6160 != 0) goto <D.6161>; else goto <D.6157>;
          <D.6161>:
          D.5996 = m->least_addr;
          D.6162 = D.5996 <= F;
          D.6163 = (long int) D.6162;
          D.6164 = __builtin_expect (D.6163, 1);
          if (D.6164 != 0) goto <D.6165>; else goto <D.6157>;
          <D.6165>:
          F->bk = TP;
          D.6166 = F->bk;
          T->fd = D.6166;
          TP->fd = F;
          TP->bk = T;
          TP->parent = 0B;
          goto <D.4864>;
          <D.6157>:
          abort ();
        }
        <D.6156>:
        goto <D.4866>;
        <D.4864>:
      }
      <D.6135>:
    }
  }
  <D.6104>:
  <D.5968>:
  <D.5960>:
  D.6167 = p + 8;
  return D.6167;
}


add_segment (struct malloc_state * m, char * tbase, size_t tsize, flag_t mmapped)
{
  char * D.6169;
  unsigned int D.6170;
  sizetype D.6171;
  unsigned int iftmp.53;
  void * D.6173;
  unsigned int D.6174;
  unsigned int D.6175;
  unsigned int D.6178;
  char * iftmp.54;
  char * D.6181;
  unsigned int D.6185;
  unsigned int D.6186;
  size_t * D.6187;
  int csp.55;
  int old_top.56;
  int D.6193;
  unsigned int D.6194;
  unsigned int D.6195;
  unsigned int D.6196;
  struct malloc_chunk * D.6197;
  unsigned int D.6198;
  unsigned int D.6201;
  unsigned int D.6202;
  int I.57;
  unsigned int D.6204;
  unsigned int D.6205;
  unsigned int D.6208;
  struct malloc_chunk * D.6210;
  char * D.6211;
  _Bool D.6212;
  long int D.6213;
  long int D.6214;
  unsigned int D.6225;
  unsigned int D.6226;
  int N.58;
  unsigned int D.6228;
  unsigned int D.6229;
  int K.59;
  unsigned int D.6231;
  unsigned int D.6232;
  unsigned int K.60;
  unsigned int D.6234;
  unsigned int D.6235;
  unsigned int D.6236;
  unsigned int D.6237;
  int D.6238;
  unsigned int D.6239;
  unsigned int D.6240;
  struct malloc_tree_chunk * D.6241;
  unsigned int D.6242;
  int I.61;
  unsigned int D.6244;
  unsigned int D.6245;
  unsigned int D.6248;
  struct malloc_tree_chunk * D.6249;
  int iftmp.62;
  unsigned int D.6254;
  unsigned int D.6255;
  unsigned int D.6257;
  unsigned int D.6258;
  unsigned int D.6261;
  struct malloc_tree_chunk * D.6262;
  _Bool D.6266;
  long int D.6267;
  long int D.6268;
  _Bool D.6273;
  long int D.6274;
  long int D.6275;
  _Bool D.6277;
  long int D.6278;
  long int D.6279;
  struct malloc_tree_chunk * D.6281;
  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.6169 = oldsp->base;
  D.6170 = oldsp->size;
  old_end = D.6169 + D.6170;
  ssize = 24;
  D.6171 = 4294967273 - ssize;
  rawsp = old_end + D.6171;
  D.6173 = rawsp + 8;
  D.6174 = (unsigned int) D.6173;
  D.6175 = D.6174 & 7;
  if (D.6175 != 0) goto <D.6176>; else goto <D.6177>;
  <D.6176>:
  D.6173 = rawsp + 8;
  D.6174 = (unsigned int) D.6173;
  D.6178 = -D.6174;
  iftmp.53 = D.6178 & 7;
  goto <D.6179>;
  <D.6177>:
  iftmp.53 = 0;
  <D.6179>:
  offset = iftmp.53;
  asp = rawsp + offset;
  D.6181 = old_top + 16;
  if (D.6181 > asp) goto <D.6182>; else goto <D.6183>;
  <D.6182>:
  iftmp.54 = old_top;
  goto <D.6184>;
  <D.6183>:
  iftmp.54 = asp;
  <D.6184>:
  csp = iftmp.54;
  sp = csp;
  ss = sp + 8;
  tnext = sp + ssize;
  p = tnext;
  nfences = 0;
  D.6185 = tsize + 4294967256;
  init_top (m, tbase, D.6185);
  D.6186 = ssize | 3;
  sp->head = D.6186;
  *ss = m->seg;
  m->seg.base = tbase;
  m->seg.size = tsize;
  m->seg.sflags = mmapped;
  m->seg.next = ss;
  <D.4888>:
  {
    struct malloc_chunk * nextp;

    nextp = p + 4;
    p->head = 7;
    nfences = nfences + 1;
    D.6187 = &nextp->head;
    if (D.6187 < old_end) goto <D.6188>; else goto <D.4887>;
    <D.6188>:
    p = nextp;
  }
  goto <D.4888>;
  <D.4887>:
  if (csp != old_top) goto <D.6189>; else goto <D.6190>;
  <D.6189>:
  {
    struct malloc_chunk * q;
    size_t psize;
    struct malloc_chunk * tn;

    q = old_top;
    csp.55 = (int) csp;
    old_top.56 = (int) old_top;
    D.6193 = csp.55 - old_top.56;
    psize = (size_t) D.6193;
    tn = q + psize;
    D.6194 = tn->head;
    D.6195 = D.6194 & 4294967294;
    tn->head = D.6195;
    D.6196 = psize | 1;
    q->head = D.6196;
    D.6197 = q + psize;
    D.6197->prev_foot = psize;
    D.6198 = psize >> 3;
    if (D.6198 <= 31) goto <D.6199>; else goto <D.6200>;
    <D.6199>:
    {
      bindex_t I;
      struct malloc_chunk * B;
      struct malloc_chunk * F;

      I = psize >> 3;
      D.6201 = I << 1;
      B = &m->smallbins[D.6201];
      F = B;
      D.6202 = m->smallmap;
      I.57 = (int) I;
      D.6204 = 1 << I.57;
      D.6205 = D.6202 & D.6204;
      if (D.6205 == 0) goto <D.6206>; else goto <D.6207>;
      <D.6206>:
      D.6202 = m->smallmap;
      I.57 = (int) I;
      D.6204 = 1 << I.57;
      D.6208 = D.6202 | D.6204;
      m->smallmap = D.6208;
      goto <D.6209>;
      <D.6207>:
      D.6210 = B->fd;
      D.6211 = m->least_addr;
      D.6212 = D.6210 >= D.6211;
      D.6213 = (long int) D.6212;
      D.6214 = __builtin_expect (D.6213, 1);
      if (D.6214 != 0) goto <D.6215>; else goto <D.6216>;
      <D.6215>:
      F = B->fd;
      goto <D.6217>;
      <D.6216>:
      abort ();
      <D.6217>:
      <D.6209>:
      B->fd = q;
      F->bk = q;
      q->fd = F;
      q->bk = B;
    }
    goto <D.6218>;
    <D.6200>:
    {
      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.6219>; else goto <D.6220>;
          <D.6219>:
          I = 0;
          goto <D.6221>;
          <D.6220>:
          if (X > 65535) goto <D.6222>; else goto <D.6223>;
          <D.6222>:
          I = 31;
          goto <D.6224>;
          <D.6223>:
          {
            unsigned int Y;
            unsigned int N;
            unsigned int K;

            Y = X;
            D.6225 = Y + 4294967040;
            D.6226 = D.6225 >> 16;
            N = D.6226 & 8;
            N.58 = (int) N;
            Y = Y << N.58;
            D.6228 = Y + 4294963200;
            D.6229 = D.6228 >> 16;
            K = D.6229 & 4;
            N = N + K;
            K.59 = (int) K;
            Y = Y << K.59;
            D.6231 = Y + 4294950912;
            D.6232 = D.6231 >> 16;
            K = D.6232 & 2;
            K.60 = K;
            N = K.60 + N;
            K.59 = (int) K;
            Y = Y << K.59;
            D.6234 = Y >> 15;
            D.6235 = D.6234 - N;
            K = D.6235 + 14;
            D.6236 = K << 1;
            D.6237 = K + 7;
            D.6238 = (int) D.6237;
            D.6239 = psize >> D.6238;
            D.6240 = D.6239 & 1;
            I = D.6236 + D.6240;
          }
          <D.6224>:
          <D.6221>:
        }
        H = &m->treebins[I];
        TP->index = I;
        TP->child[1] = 0B;
        D.6241 = TP->child[1];
        TP->child[0] = D.6241;
        D.6242 = m->treemap;
        I.61 = (int) I;
        D.6244 = 1 << I.61;
        D.6245 = D.6242 & D.6244;
        if (D.6245 == 0) goto <D.6246>; else goto <D.6247>;
        <D.6246>:
        D.6242 = m->treemap;
        I.61 = (int) I;
        D.6244 = 1 << I.61;
        D.6248 = D.6242 | D.6244;
        m->treemap = D.6248;
        *H = TP;
        TP->parent = H;
        TP->bk = TP;
        D.6249 = TP->bk;
        TP->fd = D.6249;
        goto <D.6250>;
        <D.6247>:
        {
          struct malloc_tree_chunk * T;
          size_t K;

          T = *H;
          if (I != 31) goto <D.6252>; else goto <D.6253>;
          <D.6252>:
          D.6254 = I >> 1;
          D.6255 = 25 - D.6254;
          iftmp.62 = (int) D.6255;
          goto <D.6256>;
          <D.6253>:
          iftmp.62 = 0;
          <D.6256>:
          K = psize << iftmp.62;
          <D.4907>:
          D.6257 = T->head;
          D.6258 = D.6257 & 4294967292;
          if (D.6258 != psize) goto <D.6259>; else goto <D.6260>;
          <D.6259>:
          {
            struct malloc_tree_chunk * * C;

            D.6261 = K >> 31;
            C = &T->child[D.6261];
            K = K << 1;
            D.6262 = *C;
            if (D.6262 != 0B) goto <D.6263>; else goto <D.6264>;
            <D.6263>:
            T = *C;
            goto <D.6265>;
            <D.6264>:
            D.6211 = m->least_addr;
            D.6266 = D.6211 <= C;
            D.6267 = (long int) D.6266;
            D.6268 = __builtin_expect (D.6267, 1);
            if (D.6268 != 0) goto <D.6269>; else goto <D.6270>;
            <D.6269>:
            *C = TP;
            TP->parent = T;
            TP->bk = TP;
            D.6249 = TP->bk;
            TP->fd = D.6249;
            goto <D.4905>;
            <D.6270>:
            abort ();
            <D.6265>:
          }
          goto <D.6271>;
          <D.6260>:
          {
            struct malloc_tree_chunk * F;

            F = T->fd;
            D.6211 = m->least_addr;
            D.6273 = D.6211 <= T;
            D.6274 = (long int) D.6273;
            D.6275 = __builtin_expect (D.6274, 1);
            if (D.6275 != 0) goto <D.6276>; else goto <D.6272>;
            <D.6276>:
            D.6211 = m->least_addr;
            D.6277 = D.6211 <= F;
            D.6278 = (long int) D.6277;
            D.6279 = __builtin_expect (D.6278, 1);
            if (D.6279 != 0) goto <D.6280>; else goto <D.6272>;
            <D.6280>:
            F->bk = TP;
            D.6281 = F->bk;
            T->fd = D.6281;
            TP->fd = F;
            TP->bk = T;
            TP->parent = 0B;
            goto <D.4905>;
            <D.6272>:
            abort ();
          }
          <D.6271>:
          goto <D.4907>;
          <D.4905>:
        }
        <D.6250>:
      }
    }
    <D.6218>:
  }
  <D.6190>:
}


segment_holding (struct malloc_state * m, char * addr)
{
  char * D.6282;
  unsigned int D.6285;
  char * D.6286;
  struct malloc_segment * D.6289;
  struct malloc_segment * sp;

  sp = &m->seg;
  <D.4788>:
  D.6282 = sp->base;
  if (D.6282 <= addr) goto <D.6283>; else goto <D.6284>;
  <D.6283>:
  D.6282 = sp->base;
  D.6285 = sp->size;
  D.6286 = D.6282 + D.6285;
  if (D.6286 > addr) goto <D.6287>; else goto <D.6288>;
  <D.6287>:
  D.6289 = sp;
  return D.6289;
  <D.6288>:
  <D.6284>:
  sp = sp->next;
  if (sp == 0B) goto <D.6290>; else goto <D.6291>;
  <D.6290>:
  D.6289 = 0B;
  return D.6289;
  <D.6291>:
  goto <D.4788>;
}


dlfree (void * mem)
{
  unsigned int D.6299;
  int D.6301;
  unsigned int D.6302;
  unsigned int D.6303;
  int D.6304;
  char * D.6305;
  _Bool D.6306;
  long int D.6307;
  long int D.6308;
  unsigned int D.6311;
  unsigned int D.6312;
  _Bool D.6313;
  long int D.6314;
  long int D.6315;
  unsigned int D.6318;
  unsigned int D.6321;
  unsigned int D.6324;
  sizetype D.6325;
  void * D.6326;
  int D.6327;
  unsigned int D.6330;
  unsigned int D.6331;
  _Bool D.6332;
  long int D.6333;
  long int D.6334;
  struct malloc_chunk * D.6336;
  unsigned int D.6339;
  unsigned int D.6344;
  int I.63;
  unsigned int D.6346;
  unsigned int D.6347;
  unsigned int D.6348;
  int iftmp.64;
  unsigned int D.6356;
  struct malloc_chunk * * D.6357;
  _Bool D.6358;
  long int D.6359;
  long int D.6360;
  _Bool D.6362;
  long int D.6363;
  long int D.6364;
  int iftmp.65;
  _Bool D.6370;
  long int D.6371;
  long int D.6372;
  _Bool D.6374;
  long int D.6375;
  long int D.6376;
  struct malloc_tree_chunk * D.6379;
  _Bool D.6382;
  long int D.6383;
  long int D.6384;
  struct malloc_tree_chunk * D.6392;
  _Bool D.6394;
  long int D.6395;
  long int D.6396;
  unsigned int D.6402;
  struct malloc_tree_chunk * D.6403;
  unsigned int D.6408;
  int D.6409;
  unsigned int D.6410;
  unsigned int D.6411;
  unsigned int D.6412;
  _Bool D.6414;
  long int D.6415;
  long int D.6416;
  struct malloc_tree_chunk * D.6419;
  _Bool D.6426;
  long int D.6427;
  long int D.6428;
  _Bool D.6433;
  long int D.6434;
  long int D.6435;
  _Bool D.6441;
  long int D.6442;
  long int D.6443;
  unsigned int D.6449;
  unsigned int D.6450;
  unsigned int D.6453;
  unsigned int D.6454;
  struct malloc_chunk * D.6455;
  _Bool D.6456;
  long int D.6457;
  long int D.6458;
  unsigned int D.6461;
  _Bool D.6462;
  long int D.6463;
  long int D.6464;
  unsigned int D.6467;
  struct malloc_chunk * D.6470;
  unsigned int D.6473;
  unsigned int D.6474;
  unsigned int D.6475;
  unsigned int D.6478;
  unsigned int D.6483;
  unsigned int D.6484;
  unsigned int D.6485;
  struct malloc_chunk * D.6486;
  unsigned int D.6487;
  int I.66;
  unsigned int D.6493;
  unsigned int D.6494;
  unsigned int D.6495;
  int iftmp.67;
  unsigned int D.6503;
  struct malloc_chunk * * D.6504;
  _Bool D.6505;
  long int D.6506;
  long int D.6507;
  _Bool D.6509;
  long int D.6510;
  long int D.6511;
  int iftmp.68;
  _Bool D.6517;
  long int D.6518;
  long int D.6519;
  _Bool D.6521;
  long int D.6522;
  long int D.6523;
  struct malloc_tree_chunk * D.6526;
  _Bool D.6529;
  long int D.6530;
  long int D.6531;
  struct malloc_tree_chunk * D.6539;
  _Bool D.6541;
  long int D.6542;
  long int D.6543;
  unsigned int D.6549;
  struct malloc_tree_chunk * D.6550;
  int D.6555;
  unsigned int D.6556;
  unsigned int D.6557;
  unsigned int D.6558;
  _Bool D.6560;
  long int D.6561;
  long int D.6562;
  struct malloc_tree_chunk * D.6565;
  _Bool D.6572;
  long int D.6573;
  long int D.6574;
  _Bool D.6579;
  long int D.6580;
  long int D.6581;
  _Bool D.6587;
  long int D.6588;
  long int D.6589;
  unsigned int D.6597;
  unsigned int D.6600;
  int I.69;
  unsigned int D.6602;
  unsigned int D.6603;
  unsigned int D.6606;
  struct malloc_chunk * D.6608;
  _Bool D.6609;
  long int D.6610;
  long int D.6611;
  unsigned int D.6622;
  unsigned int D.6623;
  int N.70;
  unsigned int D.6625;
  unsigned int D.6626;
  int K.71;
  unsigned int D.6628;
  unsigned int D.6629;
  unsigned int K.72;
  unsigned int D.6631;
  unsigned int D.6632;
  unsigned int D.6633;
  unsigned int D.6634;
  int D.6635;
  unsigned int D.6636;
  unsigned int D.6637;
  struct malloc_tree_chunk * D.6638;
  int I.73;
  unsigned int D.6640;
  unsigned int D.6641;
  unsigned int D.6644;
  struct malloc_tree_chunk * D.6645;
  int iftmp.74;
  unsigned int D.6650;
  unsigned int D.6651;
  unsigned int D.6653;
  unsigned int D.6654;
  unsigned int D.6657;
  struct malloc_tree_chunk * D.6658;
  _Bool D.6662;
  long int D.6663;
  long int D.6664;
  _Bool D.6669;
  long int D.6670;
  long int D.6671;
  _Bool D.6673;
  long int D.6674;
  long int D.6675;
  struct malloc_tree_chunk * D.6677;
  void postaction = <<< error >>>;
  void erroraction = <<< error >>>;

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

    p = mem + 4294967288;
    D.6299 = mparams.page_size;
    if (D.6299 != 0) goto <D.6295>; else goto <D.6300>;
    <D.6300>:
    D.6301 = init_mparams ();
    if (D.6301 == 0) goto <D.6295>; else goto <D.6296>;
    <D.6295>:
    D.6302 = _gm_.mflags;
    D.6303 = D.6302 & 2;
    if (D.6303 == 0) goto <D.6297>; else goto <D.6296>;
    <D.6296>:
    D.6304 = pthread_mutex_lock (&_gm_.mutex);
    if (D.6304 == 0) goto <D.6297>; else goto <D.6298>;
    <D.6297>:
    D.6305 = _gm_.least_addr;
    D.6306 = D.6305 <= p;
    D.6307 = (long int) D.6306;
    D.6308 = __builtin_expect (D.6307, 1);
    if (D.6308 != 0) goto <D.6309>; else goto <D.6310>;
    <D.6309>:
    D.6311 = p->head;
    D.6312 = D.6311 & 2;
    D.6313 = D.6312 != 0;
    D.6314 = (long int) D.6313;
    D.6315 = __builtin_expect (D.6314, 1);
    if (D.6315 != 0) goto <D.6316>; else goto <D.6317>;
    <D.6316>:
    {
      size_t psize;
      struct malloc_chunk * next;

      D.6311 = p->head;
      psize = D.6311 & 4294967292;
      next = p + psize;
      D.6311 = p->head;
      D.6318 = D.6311 & 1;
      if (D.6318 == 0) goto <D.6319>; else goto <D.6320>;
      <D.6319>:
      {
        size_t prevsize;

        prevsize = p->prev_foot;
        D.6321 = prevsize & 1;
        if (D.6321 != 0) goto <D.6322>; else goto <D.6323>;
        <D.6322>:
        prevsize = prevsize & 4294967294;
        D.6324 = prevsize + psize;
        psize = D.6324 + 16;
        D.6325 = -prevsize;
        D.6326 = p + D.6325;
        D.6327 = munmap (D.6326, psize);
        if (D.6327 == 0) goto <D.6328>; else goto <D.6329>;
        <D.6328>:
        D.6330 = _gm_.footprint;
        D.6331 = D.6330 - psize;
        _gm_.footprint = D.6331;
        <D.6329>:
        goto postaction;
        <D.6323>:
        {
          struct malloc_chunk * prev;

          D.6325 = -prevsize;
          prev = p + D.6325;
          psize = psize + prevsize;
          p = prev;
          D.6305 = _gm_.least_addr;
          D.6332 = D.6305 <= prev;
          D.6333 = (long int) D.6332;
          D.6334 = __builtin_expect (D.6333, 1);
          if (D.6334 != 0) goto <D.6335>; else goto erroraction;
          <D.6335>:
          D.6336 = _gm_.dv;
          if (D.6336 != p) goto <D.6337>; else goto <D.6338>;
          <D.6337>:
          D.6339 = prevsize >> 3;
          if (D.6339 <= 31) goto <D.6340>; else goto <D.6341>;
          <D.6340>:
          {
            struct malloc_chunk * F;
            struct malloc_chunk * B;
            bindex_t I;

            F = p->fd;
            B = p->bk;
            I = prevsize >> 3;
            if (F == B) goto <D.6342>; else goto <D.6343>;
            <D.6342>:
            D.6344 = _gm_.smallmap;
            I.63 = (int) I;
            D.6346 = 1 << I.63;
            D.6347 = ~D.6346;
            D.6348 = D.6344 & D.6347;
            _gm_.smallmap = D.6348;
            goto <D.6349>;
            <D.6343>:
            D.6356 = I << 1;
            D.6357 = &_gm_.smallbins[D.6356];
            D.6358 = D.6357 == F;
            D.6359 = (long int) D.6358;
            D.6360 = __builtin_expect (D.6359, 1);
            if (D.6360 != 0) goto <D.6353>; else goto <D.6361>;
            <D.6361>:
            D.6305 = _gm_.least_addr;
            D.6362 = D.6305 <= F;
            D.6363 = (long int) D.6362;
            D.6364 = __builtin_expect (D.6363, 1);
            if (D.6364 != 0) goto <D.6353>; else goto <D.6354>;
            <D.6353>:
            iftmp.64 = 1;
            goto <D.6355>;
            <D.6354>:
            iftmp.64 = 0;
            <D.6355>:
            if (iftmp.64 != 0) goto <D.6365>; else goto <D.6350>;
            <D.6365>:
            D.6356 = I << 1;
            D.6357 = &_gm_.smallbins[D.6356];
            D.6370 = D.6357 == B;
            D.6371 = (long int) D.6370;
            D.6372 = __builtin_expect (D.6371, 1);
            if (D.6372 != 0) goto <D.6367>; else goto <D.6373>;
            <D.6373>:
            D.6305 = _gm_.least_addr;
            D.6374 = D.6305 <= B;
            D.6375 = (long int) D.6374;
            D.6376 = __builtin_expect (D.6375, 1);
            if (D.6376 != 0) goto <D.6367>; else goto <D.6368>;
            <D.6367>:
            iftmp.65 = 1;
            goto <D.6369>;
            <D.6368>:
            iftmp.65 = 0;
            <D.6369>:
            if (iftmp.65 != 0) goto <D.6377>; else goto <D.6350>;
            <D.6377>:
            F->bk = B;
            B->fd = F;
            goto <D.6351>;
            <D.6350>:
            abort ();
            <D.6351>:
            <D.6349>:
          }
          goto <D.6378>;
          <D.6341>:
          {
            struct malloc_tree_chunk * TP;

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

              XP = TP->parent;
              D.6379 = TP->bk;
              if (D.6379 != TP) goto <D.6380>; else goto <D.6381>;
              <D.6380>:
              {
                struct malloc_tree_chunk * F;

                F = TP->fd;
                R = TP->bk;
                D.6305 = _gm_.least_addr;
                D.6382 = D.6305 <= F;
                D.6383 = (long int) D.6382;
                D.6384 = __builtin_expect (D.6383, 1);
                if (D.6384 != 0) goto <D.6385>; else goto <D.6386>;
                <D.6385>:
                F->bk = R;
                R->fd = F;
                goto <D.6387>;
                <D.6386>:
                abort ();
                <D.6387>:
              }
              goto <D.6388>;
              <D.6381>:
              {
                struct malloc_tree_chunk * * RP;

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

                  goto <D.5156>;
                  <D.5155>:
                  RP = CP;
                  R = *RP;
                  <D.5156>:
                  CP = &R->child[1];
                  D.6392 = *CP;
                  if (D.6392 != 0B) goto <D.5155>; else goto <D.6393>;
                  <D.6393>:
                  CP = &R->child[0];
                  D.6392 = *CP;
                  if (D.6392 != 0B) goto <D.5155>; else goto <D.5157>;
                  <D.5157>:
                  D.6305 = _gm_.least_addr;
                  D.6394 = D.6305 <= RP;
                  D.6395 = (long int) D.6394;
                  D.6396 = __builtin_expect (D.6395, 1);
                  if (D.6396 != 0) goto <D.6397>; else goto <D.6398>;
                  <D.6397>:
                  *RP = 0B;
                  goto <D.6399>;
                  <D.6398>:
                  abort ();
                  <D.6399>:
                }
                <D.6390>:
              }
              <D.6388>:
              if (XP != 0B) goto <D.6400>; else goto <D.6401>;
              <D.6400>:
              {
                struct malloc_tree_chunk * * H;

                D.6402 = TP->index;
                H = &_gm_.treebins[D.6402];
                D.6403 = *H;
                if (D.6403 == TP) goto <D.6404>; else goto <D.6405>;
                <D.6404>:
                *H = R;
                D.6403 = *H;
                if (D.6403 == 0B) goto <D.6406>; else goto <D.6407>;
                <D.6406>:
                D.6408 = _gm_.treemap;
                D.6402 = TP->index;
                D.6409 = (int) D.6402;
                D.6410 = 1 << D.6409;
                D.6411 = ~D.6410;
                D.6412 = D.6408 & D.6411;
                _gm_.treemap = D.6412;
                <D.6407>:
                goto <D.6413>;
                <D.6405>:
                D.6305 = _gm_.least_addr;
                D.6414 = D.6305 <= XP;
                D.6415 = (long int) D.6414;
                D.6416 = __builtin_expect (D.6415, 1);
                if (D.6416 != 0) goto <D.6417>; else goto <D.6418>;
                <D.6417>:
                D.6419 = XP->child[0];
                if (D.6419 == TP) goto <D.6420>; else goto <D.6421>;
                <D.6420>:
                XP->child[0] = R;
                goto <D.6422>;
                <D.6421>:
                XP->child[1] = R;
                <D.6422>:
                goto <D.6423>;
                <D.6418>:
                abort ();
                <D.6423>:
                <D.6413>:
                if (R != 0B) goto <D.6424>; else goto <D.6425>;
                <D.6424>:
                D.6305 = _gm_.least_addr;
                D.6426 = D.6305 <= R;
                D.6427 = (long int) D.6426;
                D.6428 = __builtin_expect (D.6427, 1);
                if (D.6428 != 0) goto <D.6429>; else goto <D.6430>;
                <D.6429>:
                {
                  struct malloc_tree_chunk * C0;
                  struct malloc_tree_chunk * C1;

                  R->parent = XP;
                  C0 = TP->child[0];
                  if (C0 != 0B) goto <D.6431>; else goto <D.6432>;
                  <D.6431>:
                  D.6305 = _gm_.least_addr;
                  D.6433 = D.6305 <= C0;
                  D.6434 = (long int) D.6433;
                  D.6435 = __builtin_expect (D.6434, 1);
                  if (D.6435 != 0) goto <D.6436>; else goto <D.6437>;
                  <D.6436>:
                  R->child[0] = C0;
                  C0->parent = R;
                  goto <D.6438>;
                  <D.6437>:
                  abort ();
                  <D.6438>:
                  <D.6432>:
                  C1 = TP->child[1];
                  if (C1 != 0B) goto <D.6439>; else goto <D.6440>;
                  <D.6439>:
                  D.6305 = _gm_.least_addr;
                  D.6441 = D.6305 <= C1;
                  D.6442 = (long int) D.6441;
                  D.6443 = __builtin_expect (D.6442, 1);
                  if (D.6443 != 0) goto <D.6444>; else goto <D.6445>;
                  <D.6444>:
                  R->child[1] = C1;
                  C1->parent = R;
                  goto <D.6446>;
                  <D.6445>:
                  abort ();
                  <D.6446>:
                  <D.6440>:
                }
                goto <D.6447>;
                <D.6430>:
                abort ();
                <D.6447>:
                <D.6425>:
              }
              <D.6401>:
            }
          }
          <D.6378>:
          goto <D.6448>;
          <D.6338>:
          D.6449 = next->head;
          D.6450 = D.6449 & 3;
          if (D.6450 == 3) goto <D.6451>; else goto <D.6452>;
          <D.6451>:
          _gm_.dvsize = psize;
          D.6449 = next->head;
          D.6453 = D.6449 & 4294967294;
          next->head = D.6453;
          D.6454 = psize | 1;
          p->head = D.6454;
          D.6455 = p + psize;
          D.6455->prev_foot = psize;
          goto postaction;
          <D.6452>:
          <D.6448>:
        }
      }
      <D.6320>:
      D.6456 = p < next;
      D.6457 = (long int) D.6456;
      D.6458 = __builtin_expect (D.6457, 1);
      if (D.6458 != 0) goto <D.6459>; else goto <D.6460>;
      <D.6459>:
      D.6449 = next->head;
      D.6461 = D.6449 & 1;
      D.6462 = D.6461 != 0;
      D.6463 = (long int) D.6462;
      D.6464 = __builtin_expect (D.6463, 1);
      if (D.6464 != 0) goto <D.6465>; else goto <D.6466>;
      <D.6465>:
      D.6449 = next->head;
      D.6467 = D.6449 & 2;
      if (D.6467 == 0) goto <D.6468>; else goto <D.6469>;
      <D.6468>:
      D.6470 = _gm_.top;
      if (D.6470 == next) goto <D.6471>; else goto <D.6472>;
      <D.6471>:
      {
        size_t tsize;

        D.6473 = _gm_.topsize;
        D.6474 = D.6473 + psize;
        _gm_.topsize = D.6474;
        tsize = _gm_.topsize;
        _gm_.top = p;
        D.6475 = tsize | 1;
        p->head = D.6475;
        D.6336 = _gm_.dv;
        if (D.6336 == p) goto <D.6476>; else goto <D.6477>;
        <D.6476>:
        _gm_.dv = 0B;
        _gm_.dvsize = 0;
        <D.6477>:
        D.6478 = _gm_.trim_check;
        if (D.6478 < tsize) goto <D.6479>; else goto <D.6480>;
        <D.6479>:
        sys_trim (&_gm_, 0);
        <D.6480>:
        goto postaction;
      }
      <D.6472>:
      D.6336 = _gm_.dv;
      if (D.6336 == next) goto <D.6481>; else goto <D.6482>;
      <D.6481>:
      {
        size_t dsize;

        D.6483 = _gm_.dvsize;
        D.6484 = D.6483 + psize;
        _gm_.dvsize = D.6484;
        dsize = _gm_.dvsize;
        _gm_.dv = p;
        D.6485 = dsize | 1;
        p->head = D.6485;
        D.6486 = p + dsize;
        D.6486->prev_foot = dsize;
        goto postaction;
      }
      <D.6482>:
      {
        size_t nsize;

        D.6449 = next->head;
        nsize = D.6449 & 4294967292;
        psize = psize + nsize;
        D.6487 = nsize >> 3;
        if (D.6487 <= 31) goto <D.6488>; else goto <D.6489>;
        <D.6488>:
        {
          struct malloc_chunk * F;
          struct malloc_chunk * B;
          bindex_t I;

          F = next->fd;
          B = next->bk;
          I = nsize >> 3;
          if (F == B) goto <D.6490>; else goto <D.6491>;
          <D.6490>:
          D.6344 = _gm_.smallmap;
          I.66 = (int) I;
          D.6493 = 1 << I.66;
          D.6494 = ~D.6493;
          D.6495 = D.6344 & D.6494;
          _gm_.smallmap = D.6495;
          goto <D.6496>;
          <D.6491>:
          D.6503 = I << 1;
          D.6504 = &_gm_.smallbins[D.6503];
          D.6505 = D.6504 == F;
          D.6506 = (long int) D.6505;
          D.6507 = __builtin_expect (D.6506, 1);
          if (D.6507 != 0) goto <D.6500>; else goto <D.6508>;
          <D.6508>:
          D.6305 = _gm_.least_addr;
          D.6509 = D.6305 <= F;
          D.6510 = (long int) D.6509;
          D.6511 = __builtin_expect (D.6510, 1);
          if (D.6511 != 0) goto <D.6500>; else goto <D.6501>;
          <D.6500>:
          iftmp.67 = 1;
          goto <D.6502>;
          <D.6501>:
          iftmp.67 = 0;
          <D.6502>:
          if (iftmp.67 != 0) goto <D.6512>; else goto <D.6497>;
          <D.6512>:
          D.6503 = I << 1;
          D.6504 = &_gm_.smallbins[D.6503];
          D.6517 = D.6504 == B;
          D.6518 = (long int) D.6517;
          D.6519 = __builtin_expect (D.6518, 1);
          if (D.6519 != 0) goto <D.6514>; else goto <D.6520>;
          <D.6520>:
          D.6305 = _gm_.least_addr;
          D.6521 = D.6305 <= B;
          D.6522 = (long int) D.6521;
          D.6523 = __builtin_expect (D.6522, 1);
          if (D.6523 != 0) goto <D.6514>; else goto <D.6515>;
          <D.6514>:
          iftmp.68 = 1;
          goto <D.6516>;
          <D.6515>:
          iftmp.68 = 0;
          <D.6516>:
          if (iftmp.68 != 0) goto <D.6524>; else goto <D.6497>;
          <D.6524>:
          F->bk = B;
          B->fd = F;
          goto <D.6498>;
          <D.6497>:
          abort ();
          <D.6498>:
          <D.6496>:
        }
        goto <D.6525>;
        <D.6489>:
        {
          struct malloc_tree_chunk * TP;

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

            XP = TP->parent;
            D.6526 = TP->bk;
            if (D.6526 != TP) goto <D.6527>; else goto <D.6528>;
            <D.6527>:
            {
              struct malloc_tree_chunk * F;

              F = TP->fd;
              R = TP->bk;
              D.6305 = _gm_.least_addr;
              D.6529 = D.6305 <= F;
              D.6530 = (long int) D.6529;
              D.6531 = __builtin_expect (D.6530, 1);
              if (D.6531 != 0) goto <D.6532>; else goto <D.6533>;
              <D.6532>:
              F->bk = R;
              R->fd = F;
              goto <D.6534>;
              <D.6533>:
              abort ();
              <D.6534>:
            }
            goto <D.6535>;
            <D.6528>:
            {
              struct malloc_tree_chunk * * RP;

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

                goto <D.5175>;
                <D.5174>:
                RP = CP;
                R = *RP;
                <D.5175>:
                CP = &R->child[1];
                D.6539 = *CP;
                if (D.6539 != 0B) goto <D.5174>; else goto <D.6540>;
                <D.6540>:
                CP = &R->child[0];
                D.6539 = *CP;
                if (D.6539 != 0B) goto <D.5174>; else goto <D.5176>;
                <D.5176>:
                D.6305 = _gm_.least_addr;
                D.6541 = D.6305 <= RP;
                D.6542 = (long int) D.6541;
                D.6543 = __builtin_expect (D.6542, 1);
                if (D.6543 != 0) goto <D.6544>; else goto <D.6545>;
                <D.6544>:
                *RP = 0B;
                goto <D.6546>;
                <D.6545>:
                abort ();
                <D.6546>:
              }
              <D.6537>:
            }
            <D.6535>:
            if (XP != 0B) goto <D.6547>; else goto <D.6548>;
            <D.6547>:
            {
              struct malloc_tree_chunk * * H;

              D.6549 = TP->index;
              H = &_gm_.treebins[D.6549];
              D.6550 = *H;
              if (D.6550 == TP) goto <D.6551>; else goto <D.6552>;
              <D.6551>:
              *H = R;
              D.6550 = *H;
              if (D.6550 == 0B) goto <D.6553>; else goto <D.6554>;
              <D.6553>:
              D.6408 = _gm_.treemap;
              D.6549 = TP->index;
              D.6555 = (int) D.6549;
              D.6556 = 1 << D.6555;
              D.6557 = ~D.6556;
              D.6558 = D.6408 & D.6557;
              _gm_.treemap = D.6558;
              <D.6554>:
              goto <D.6559>;
              <D.6552>:
              D.6305 = _gm_.least_addr;
              D.6560 = D.6305 <= XP;
              D.6561 = (long int) D.6560;
              D.6562 = __builtin_expect (D.6561, 1);
              if (D.6562 != 0) goto <D.6563>; else goto <D.6564>;
              <D.6563>:
              D.6565 = XP->child[0];
              if (D.6565 == TP) goto <D.6566>; else goto <D.6567>;
              <D.6566>:
              XP->child[0] = R;
              goto <D.6568>;
              <D.6567>:
              XP->child[1] = R;
              <D.6568>:
              goto <D.6569>;
              <D.6564>:
              abort ();
              <D.6569>:
              <D.6559>:
              if (R != 0B) goto <D.6570>; else goto <D.6571>;
              <D.6570>:
              D.6305 = _gm_.least_addr;
              D.6572 = D.6305 <= R;
              D.6573 = (long int) D.6572;
              D.6574 = __builtin_expect (D.6573, 1);
              if (D.6574 != 0) goto <D.6575>; else goto <D.6576>;
              <D.6575>:
              {
                struct malloc_tree_chunk * C0;
                struct malloc_tree_chunk * C1;

                R->parent = XP;
                C0 = TP->child[0];
                if (C0 != 0B) goto <D.6577>; else goto <D.6578>;
                <D.6577>:
                D.6305 = _gm_.least_addr;
                D.6579 = D.6305 <= C0;
                D.6580 = (long int) D.6579;
                D.6581 = __builtin_expect (D.6580, 1);
                if (D.6581 != 0) goto <D.6582>; else goto <D.6583>;
                <D.6582>:
                R->child[0] = C0;
                C0->parent = R;
                goto <D.6584>;
                <D.6583>:
                abort ();
                <D.6584>:
                <D.6578>:
                C1 = TP->child[1];
                if (C1 != 0B) goto <D.6585>; else goto <D.6586>;
                <D.6585>:
                D.6305 = _gm_.least_addr;
                D.6587 = D.6305 <= C1;
                D.6588 = (long int) D.6587;
                D.6589 = __builtin_expect (D.6588, 1);
                if (D.6589 != 0) goto <D.6590>; else goto <D.6591>;
                <D.6590>:
                R->child[1] = C1;
                C1->parent = R;
                goto <D.6592>;
                <D.6591>:
                abort ();
                <D.6592>:
                <D.6586>:
              }
              goto <D.6593>;
              <D.6576>:
              abort ();
              <D.6593>:
              <D.6571>:
            }
            <D.6548>:
          }
        }
        <D.6525>:
        D.6454 = psize | 1;
        p->head = D.6454;
        D.6455 = p + psize;
        D.6455->prev_foot = psize;
        D.6336 = _gm_.dv;
        if (D.6336 == p) goto <D.6594>; else goto <D.6595>;
        <D.6594>:
        _gm_.dvsize = psize;
        goto postaction;
        <D.6595>:
      }
      goto <D.6596>;
      <D.6469>:
      D.6449 = next->head;
      D.6453 = D.6449 & 4294967294;
      next->head = D.6453;
      D.6454 = psize | 1;
      p->head = D.6454;
      D.6455 = p + psize;
      D.6455->prev_foot = psize;
      <D.6596>:
      D.6597 = psize >> 3;
      if (D.6597 <= 31) goto <D.6598>; else goto <D.6599>;
      <D.6598>:
      {
        bindex_t I;
        struct malloc_chunk * B;
        struct malloc_chunk * F;

        I = psize >> 3;
        D.6600 = I << 1;
        B = &_gm_.smallbins[D.6600];
        F = B;
        D.6344 = _gm_.smallmap;
        I.69 = (int) I;
        D.6602 = 1 << I.69;
        D.6603 = D.6344 & D.6602;
        if (D.6603 == 0) goto <D.6604>; else goto <D.6605>;
        <D.6604>:
        D.6344 = _gm_.smallmap;
        I.69 = (int) I;
        D.6602 = 1 << I.69;
        D.6606 = D.6344 | D.6602;
        _gm_.smallmap = D.6606;
        goto <D.6607>;
        <D.6605>:
        D.6608 = B->fd;
        D.6305 = _gm_.least_addr;
        D.6609 = D.6608 >= D.6305;
        D.6610 = (long int) D.6609;
        D.6611 = __builtin_expect (D.6610, 1);
        if (D.6611 != 0) goto <D.6612>; else goto <D.6613>;
        <D.6612>:
        F = B->fd;
        goto <D.6614>;
        <D.6613>:
        abort ();
        <D.6614>:
        <D.6607>:
        B->fd = p;
        F->bk = p;
        p->fd = F;
        p->bk = B;
      }
      goto <D.6615>;
      <D.6599>:
      {
        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.6616>; else goto <D.6617>;
            <D.6616>:
            I = 0;
            goto <D.6618>;
            <D.6617>:
            if (X > 65535) goto <D.6619>; else goto <D.6620>;
            <D.6619>:
            I = 31;
            goto <D.6621>;
            <D.6620>:
            {
              unsigned int Y;
              unsigned int N;
              unsigned int K;

              Y = X;
              D.6622 = Y + 4294967040;
              D.6623 = D.6622 >> 16;
              N = D.6623 & 8;
              N.70 = (int) N;
              Y = Y << N.70;
              D.6625 = Y + 4294963200;
              D.6626 = D.6625 >> 16;
              K = D.6626 & 4;
              N = N + K;
              K.71 = (int) K;
              Y = Y << K.71;
              D.6628 = Y + 4294950912;
              D.6629 = D.6628 >> 16;
              K = D.6629 & 2;
              K.72 = K;
              N = K.72 + N;
              K.71 = (int) K;
              Y = Y << K.71;
              D.6631 = Y >> 15;
              D.6632 = D.6631 - N;
              K = D.6632 + 14;
              D.6633 = K << 1;
              D.6634 = K + 7;
              D.6635 = (int) D.6634;
              D.6636 = psize >> D.6635;
              D.6637 = D.6636 & 1;
              I = D.6633 + D.6637;
            }
            <D.6621>:
            <D.6618>:
          }
          H = &_gm_.treebins[I];
          TP->index = I;
          TP->child[1] = 0B;
          D.6638 = TP->child[1];
          TP->child[0] = D.6638;
          D.6408 = _gm_.treemap;
          I.73 = (int) I;
          D.6640 = 1 << I.73;
          D.6641 = D.6408 & D.6640;
          if (D.6641 == 0) goto <D.6642>; else goto <D.6643>;
          <D.6642>:
          D.6408 = _gm_.treemap;
          I.73 = (int) I;
          D.6640 = 1 << I.73;
          D.6644 = D.6408 | D.6640;
          _gm_.treemap = D.6644;
          *H = TP;
          TP->parent = H;
          TP->bk = TP;
          D.6645 = TP->bk;
          TP->fd = D.6645;
          goto <D.6646>;
          <D.6643>:
          {
            struct malloc_tree_chunk * T;
            size_t K;

            T = *H;
            if (I != 31) goto <D.6648>; else goto <D.6649>;
            <D.6648>:
            D.6650 = I >> 1;
            D.6651 = 25 - D.6650;
            iftmp.74 = (int) D.6651;
            goto <D.6652>;
            <D.6649>:
            iftmp.74 = 0;
            <D.6652>:
            K = psize << iftmp.74;
            <D.5195>:
            D.6653 = T->head;
            D.6654 = D.6653 & 4294967292;
            if (D.6654 != psize) goto <D.6655>; else goto <D.6656>;
            <D.6655>:
            {
              struct malloc_tree_chunk * * C;

              D.6657 = K >> 31;
              C = &T->child[D.6657];
              K = K << 1;
              D.6658 = *C;
              if (D.6658 != 0B) goto <D.6659>; else goto <D.6660>;
              <D.6659>:
              T = *C;
              goto <D.6661>;
              <D.6660>:
              D.6305 = _gm_.least_addr;
              D.6662 = D.6305 <= C;
              D.6663 = (long int) D.6662;
              D.6664 = __builtin_expect (D.6663, 1);
              if (D.6664 != 0) goto <D.6665>; else goto <D.6666>;
              <D.6665>:
              *C = TP;
              TP->parent = T;
              TP->bk = TP;
              D.6645 = TP->bk;
              TP->fd = D.6645;
              goto <D.5193>;
              <D.6666>:
              abort ();
              <D.6661>:
            }
            goto <D.6667>;
            <D.6656>:
            {
              struct malloc_tree_chunk * F;

              F = T->fd;
              D.6305 = _gm_.least_addr;
              D.6669 = D.6305 <= T;
              D.6670 = (long int) D.6669;
              D.6671 = __builtin_expect (D.6670, 1);
              if (D.6671 != 0) goto <D.6672>; else goto <D.6668>;
              <D.6672>:
              D.6305 = _gm_.least_addr;
              D.6673 = D.6305 <= F;
              D.6674 = (long int) D.6673;
              D.6675 = __builtin_expect (D.6674, 1);
              if (D.6675 != 0) goto <D.6676>; else goto <D.6668>;
              <D.6676>:
              F->bk = TP;
              D.6677 = F->bk;
              T->fd = D.6677;
              TP->fd = F;
              TP->bk = T;
              TP->parent = 0B;
              goto <D.5193>;
              <D.6668>:
              abort ();
            }
            <D.6667>:
            goto <D.5195>;
            <D.5193>:
          }
          <D.6646>:
        }
      }
      <D.6615>:
      goto postaction;
      <D.6466>:
      <D.6460>:
    }
    <D.6317>:
    <D.6310>:
    erroraction:
    abort ();
    postaction:
    D.6302 = _gm_.mflags;
    D.6303 = D.6302 & 2;
    if (D.6303 != 0) goto <D.6678>; else goto <D.6679>;
    <D.6678>:
    pthread_mutex_unlock (&_gm_.mutex);
    <D.6679>:
    <D.6298>:
  }
  <D.6294>:
}


sys_trim (struct malloc_state * m, size_t pad)
{
  struct malloc_chunk * D.6682;
  unsigned int D.6685;
  unsigned int D.6688;
  unsigned int D.6689;
  unsigned int D.6690;
  unsigned int D.6691;
  unsigned int D.6692;
  unsigned int D.6693;
  unsigned int D.6694;
  unsigned int D.6697;
  unsigned int D.6700;
  int D.6703;
  char * D.6708;
  void * D.6709;
  void * D.6711;
  int D.6712;
  char * D.6718;
  int old_br.75;
  int new_br.76;
  int D.6727;
  unsigned int D.6730;
  unsigned int D.6731;
  unsigned int D.6732;
  unsigned int D.6733;
  unsigned int D.6736;
  int D.6739;
  _Bool D.6740;
  size_t released;

  released = 0;
  if (pad <= 4294967231) goto <D.6680>; else goto <D.6681>;
  <D.6680>:
  D.6682 = m->top;
  if (D.6682 != 0B) goto <D.6683>; else goto <D.6684>;
  <D.6683>:
  pad = pad + 40;
  D.6685 = m->topsize;
  if (D.6685 > pad) goto <D.6686>; else goto <D.6687>;
  <D.6686>:
  {
    size_t unit;
    size_t extra;
    struct malloc_segment * sp;

    unit = mparams.granularity;
    D.6685 = m->topsize;
    D.6688 = D.6685 - pad;
    D.6689 = D.6688 + unit;
    D.6690 = D.6689 + 4294967295;
    D.6691 = D.6690 / unit;
    D.6692 = D.6691 + 4294967295;
    extra = D.6692 * unit;
    D.6682 = m->top;
    sp = segment_holding (m, D.6682);
    D.6693 = sp->sflags;
    D.6694 = D.6693 & 8;
    if (D.6694 == 0) goto <D.6695>; else goto <D.6696>;
    <D.6695>:
    D.6693 = sp->sflags;
    D.6697 = D.6693 & 1;
    if (D.6697 != 0) goto <D.6698>; else goto <D.6699>;
    <D.6698>:
    D.6700 = sp->size;
    if (D.6700 >= extra) goto <D.6701>; else goto <D.6702>;
    <D.6701>:
    D.6703 = has_segment_link (m, sp);
    if (D.6703 == 0) goto <D.6704>; else goto <D.6705>;
    <D.6704>:
    {
      size_t newsize;

      D.6700 = sp->size;
      newsize = D.6700 - extra;
      D.6708 = sp->base;
      D.6700 = sp->size;
      D.6709 = mremap (D.6708, D.6700, newsize, 0);
      if (D.6709 != 4294967295B) goto <D.6706>; else goto <D.6710>;
      <D.6710>:
      D.6708 = sp->base;
      D.6711 = D.6708 + newsize;
      D.6712 = munmap (D.6711, extra);
      if (D.6712 == 0) goto <D.6706>; else goto <D.6707>;
      <D.6706>:
      released = extra;
      <D.6707>:
    }
    <D.6705>:
    <D.6702>:
    goto <D.6713>;
    <D.6699>:
    if (0 != 0) goto <D.6714>; else goto <D.6715>;
    <D.6714>:
    if (extra > 2147483646) goto <D.6716>; else goto <D.6717>;
    <D.6716>:
    extra = 2147483648 - unit;
    <D.6717>:
    {
      char * old_br;

      old_br = 4294967295B;
      D.6708 = sp->base;
      D.6700 = sp->size;
      D.6718 = D.6708 + D.6700;
      if (D.6718 == old_br) goto <D.6719>; else goto <D.6720>;
      <D.6719>:
      {
        char * rel_br;
        char * new_br;

        rel_br = 4294967295B;
        new_br = 4294967295B;
        if (rel_br != 4294967295B) goto <D.6721>; else goto <D.6722>;
        <D.6721>:
        if (new_br < old_br) goto <D.6723>; else goto <D.6724>;
        <D.6723>:
        old_br.75 = (int) old_br;
        new_br.76 = (int) new_br;
        D.6727 = old_br.75 - new_br.76;
        released = (size_t) D.6727;
        <D.6724>:
        <D.6722>:
      }
      <D.6720>:
    }
    <D.6715>:
    <D.6713>:
    <D.6696>:
    if (released != 0) goto <D.6728>; else goto <D.6729>;
    <D.6728>:
    D.6700 = sp->size;
    D.6730 = D.6700 - released;
    sp->size = D.6730;
    D.6731 = m->footprint;
    D.6732 = D.6731 - released;
    m->footprint = D.6732;
    D.6682 = m->top;
    D.6685 = m->topsize;
    D.6733 = D.6685 - released;
    init_top (m, D.6682, D.6733);
    <D.6729>:
  }
  <D.6687>:
  if (1 != 0) goto <D.6734>; else goto <D.6735>;
  <D.6734>:
  D.6736 = release_unused_segments (m);
  released = D.6736 + released;
  <D.6735>:
  if (released == 0) goto <D.6737>; else goto <D.6738>;
  <D.6737>:
  m->trim_check = 4294967295;
  <D.6738>:
  <D.6684>:
  <D.6681>:
  D.6740 = released != 0;
  D.6739 = (int) D.6740;
  return D.6739;
}


has_segment_link (struct malloc_state * m, struct malloc_segment * ss)
{
  char * D.6742;
  unsigned int D.6745;
  char * D.6746;
  int D.6749;
  struct malloc_segment * sp;

  sp = &m->seg;
  <D.4794>:
  D.6742 = ss->base;
  if (D.6742 <= sp) goto <D.6743>; else goto <D.6744>;
  <D.6743>:
  D.6742 = ss->base;
  D.6745 = ss->size;
  D.6746 = D.6742 + D.6745;
  if (D.6746 > sp) goto <D.6747>; else goto <D.6748>;
  <D.6747>:
  D.6749 = 1;
  return D.6749;
  <D.6748>:
  <D.6744>:
  sp = sp->next;
  if (sp == 0B) goto <D.6750>; else goto <D.6751>;
  <D.6750>:
  D.6749 = 0;
  return D.6749;
  <D.6751>:
  goto <D.4794>;
}


release_unused_segments (struct malloc_state * m)
{
  unsigned int D.6753;
  unsigned int D.6754;
  sizetype iftmp.77;
  void * D.6758;
  unsigned int D.6759;
  unsigned int D.6760;
  unsigned int D.6763;
  unsigned int D.6765;
  unsigned int D.6766;
  char * D.6769;
  sizetype D.6770;
  char * D.6771;
  struct malloc_chunk * D.6774;
  struct malloc_tree_chunk * D.6778;
  char * D.6781;
  _Bool D.6782;
  long int D.6783;
  long int D.6784;
  struct malloc_tree_chunk * D.6792;
  _Bool D.6794;
  long int D.6795;
  long int D.6796;
  unsigned int D.6802;
  struct malloc_tree_chunk * D.6803;
  unsigned int D.6808;
  int D.6809;
  unsigned int D.6810;
  unsigned int D.6811;
  unsigned int D.6812;
  _Bool D.6814;
  long int D.6815;
  long int D.6816;
  struct malloc_tree_chunk * D.6819;
  _Bool D.6826;
  long int D.6827;
  long int D.6828;
  _Bool D.6833;
  long int D.6834;
  long int D.6835;
  _Bool D.6841;
  long int D.6842;
  long int D.6843;
  int D.6848;
  unsigned int D.6851;
  unsigned int D.6852;
  unsigned int D.6860;
  unsigned int D.6861;
  int N.78;
  unsigned int D.6863;
  unsigned int D.6864;
  int K.79;
  unsigned int D.6866;
  unsigned int D.6867;
  unsigned int K.80;
  unsigned int D.6869;
  unsigned int D.6870;
  unsigned int D.6871;
  unsigned int D.6872;
  int D.6873;
  unsigned int D.6874;
  unsigned int D.6875;
  struct malloc_tree_chunk * D.6876;
  int I.81;
  unsigned int D.6878;
  unsigned int D.6879;
  unsigned int D.6882;
  int iftmp.82;
  unsigned int D.6887;
  unsigned int D.6888;
  unsigned int D.6890;
  unsigned int D.6891;
  unsigned int D.6894;
  struct malloc_tree_chunk * D.6895;
  _Bool D.6899;
  long int D.6900;
  long int D.6901;
  _Bool D.6906;
  long int D.6907;
  long int D.6908;
  _Bool D.6910;
  long int D.6911;
  long int D.6912;
  struct malloc_tree_chunk * D.6914;
  size_t D.6915;
  size_t released;
  struct malloc_segment * pred;
  struct malloc_segment * sp;

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

    base = sp->base;
    size = sp->size;
    next = sp->next;
    D.6753 = BIT_FIELD_REF <*sp, 32, 96>;
    D.6754 = D.6753 & 9;
    if (D.6754 == 1) goto <D.6755>; else goto <D.6756>;
    <D.6755>:
    {
      struct malloc_chunk * p;
      size_t psize;

      D.6758 = base + 8;
      D.6759 = (unsigned int) D.6758;
      D.6760 = D.6759 & 7;
      if (D.6760 != 0) goto <D.6761>; else goto <D.6762>;
      <D.6761>:
      D.6758 = base + 8;
      D.6759 = (unsigned int) D.6758;
      D.6763 = -D.6759;
      iftmp.77 = D.6763 & 7;
      goto <D.6764>;
      <D.6762>:
      iftmp.77 = 0;
      <D.6764>:
      p = base + iftmp.77;
      D.6765 = p->head;
      psize = D.6765 & 4294967292;
      D.6765 = p->head;
      D.6766 = D.6765 & 2;
      if (D.6766 == 0) goto <D.6767>; else goto <D.6768>;
      <D.6767>:
      D.6769 = p + psize;
      D.6770 = size + 4294967256;
      D.6771 = base + D.6770;
      if (D.6769 >= D.6771) goto <D.6772>; else goto <D.6773>;
      <D.6772>:
      {
        struct malloc_tree_chunk * tp;

        tp = p;
        D.6774 = m->dv;
        if (D.6774 == p) goto <D.6775>; else goto <D.6776>;
        <D.6775>:
        m->dv = 0B;
        m->dvsize = 0;
        goto <D.6777>;
        <D.6776>:
        {
          struct malloc_tree_chunk * XP;
          struct malloc_tree_chunk * R;

          XP = tp->parent;
          D.6778 = tp->bk;
          if (D.6778 != tp) goto <D.6779>; else goto <D.6780>;
          <D.6779>:
          {
            struct malloc_tree_chunk * F;

            F = tp->fd;
            R = tp->bk;
            D.6781 = m->least_addr;
            D.6782 = D.6781 <= F;
            D.6783 = (long int) D.6782;
            D.6784 = __builtin_expect (D.6783, 1);
            if (D.6784 != 0) goto <D.6785>; else goto <D.6786>;
            <D.6785>:
            F->bk = R;
            R->fd = F;
            goto <D.6787>;
            <D.6786>:
            abort ();
            <D.6787>:
          }
          goto <D.6788>;
          <D.6780>:
          {
            struct malloc_tree_chunk * * RP;

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

              goto <D.4959>;
              <D.4958>:
              RP = CP;
              R = *RP;
              <D.4959>:
              CP = &R->child[1];
              D.6792 = *CP;
              if (D.6792 != 0B) goto <D.4958>; else goto <D.6793>;
              <D.6793>:
              CP = &R->child[0];
              D.6792 = *CP;
              if (D.6792 != 0B) goto <D.4958>; else goto <D.4960>;
              <D.4960>:
              D.6781 = m->least_addr;
              D.6794 = D.6781 <= RP;
              D.6795 = (long int) D.6794;
              D.6796 = __builtin_expect (D.6795, 1);
              if (D.6796 != 0) goto <D.6797>; else goto <D.6798>;
              <D.6797>:
              *RP = 0B;
              goto <D.6799>;
              <D.6798>:
              abort ();
              <D.6799>:
            }
            <D.6790>:
          }
          <D.6788>:
          if (XP != 0B) goto <D.6800>; else goto <D.6801>;
          <D.6800>:
          {
            struct malloc_tree_chunk * * H;

            D.6802 = tp->index;
            H = &m->treebins[D.6802];
            D.6803 = *H;
            if (D.6803 == tp) goto <D.6804>; else goto <D.6805>;
            <D.6804>:
            *H = R;
            D.6803 = *H;
            if (D.6803 == 0B) goto <D.6806>; else goto <D.6807>;
            <D.6806>:
            D.6808 = m->treemap;
            D.6802 = tp->index;
            D.6809 = (int) D.6802;
            D.6810 = 1 << D.6809;
            D.6811 = ~D.6810;
            D.6812 = D.6808 & D.6811;
            m->treemap = D.6812;
            <D.6807>:
            goto <D.6813>;
            <D.6805>:
            D.6781 = m->least_addr;
            D.6814 = D.6781 <= XP;
            D.6815 = (long int) D.6814;
            D.6816 = __builtin_expect (D.6815, 1);
            if (D.6816 != 0) goto <D.6817>; else goto <D.6818>;
            <D.6817>:
            D.6819 = XP->child[0];
            if (D.6819 == tp) goto <D.6820>; else goto <D.6821>;
            <D.6820>:
            XP->child[0] = R;
            goto <D.6822>;
            <D.6821>:
            XP->child[1] = R;
            <D.6822>:
            goto <D.6823>;
            <D.6818>:
            abort ();
            <D.6823>:
            <D.6813>:
            if (R != 0B) goto <D.6824>; else goto <D.6825>;
            <D.6824>:
            D.6781 = m->least_addr;
            D.6826 = D.6781 <= R;
            D.6827 = (long int) D.6826;
            D.6828 = __builtin_expect (D.6827, 1);
            if (D.6828 != 0) goto <D.6829>; else goto <D.6830>;
            <D.6829>:
            {
              struct malloc_tree_chunk * C0;
              struct malloc_tree_chunk * C1;

              R->parent = XP;
              C0 = tp->child[0];
              if (C0 != 0B) goto <D.6831>; else goto <D.6832>;
              <D.6831>:
              D.6781 = m->least_addr;
              D.6833 = D.6781 <= C0;
              D.6834 = (long int) D.6833;
              D.6835 = __builtin_expect (D.6834, 1);
              if (D.6835 != 0) goto <D.6836>; else goto <D.6837>;
              <D.6836>:
              R->child[0] = C0;
              C0->parent = R;
              goto <D.6838>;
              <D.6837>:
              abort ();
              <D.6838>:
              <D.6832>:
              C1 = tp->child[1];
              if (C1 != 0B) goto <D.6839>; else goto <D.6840>;
              <D.6839>:
              D.6781 = m->least_addr;
              D.6841 = D.6781 <= C1;
              D.6842 = (long int) D.6841;
              D.6843 = __builtin_expect (D.6842, 1);
              if (D.6843 != 0) goto <D.6844>; else goto <D.6845>;
              <D.6844>:
              R->child[1] = C1;
              C1->parent = R;
              goto <D.6846>;
              <D.6845>:
              abort ();
              <D.6846>:
              <D.6840>:
            }
            goto <D.6847>;
            <D.6830>:
            abort ();
            <D.6847>:
            <D.6825>:
          }
          <D.6801>:
        }
        <D.6777>:
        D.6848 = munmap (base, size);
        if (D.6848 == 0) goto <D.6849>; else goto <D.6850>;
        <D.6849>:
        released = released + size;
        D.6851 = m->footprint;
        D.6852 = D.6851 - size;
        m->footprint = D.6852;
        sp = pred;
        sp->next = next;
        goto <D.6853>;
        <D.6850>:
        {
          struct malloc_tree_chunk * * H;
          bindex_t I;

          {
            size_t X;

            X = psize >> 8;
            if (X == 0) goto <D.6854>; else goto <D.6855>;
            <D.6854>:
            I = 0;
            goto <D.6856>;
            <D.6855>:
            if (X > 65535) goto <D.6857>; else goto <D.6858>;
            <D.6857>:
            I = 31;
            goto <D.6859>;
            <D.6858>:
            {
              unsigned int Y;
              unsigned int N;
              unsigned int K;

              Y = X;
              D.6860 = Y + 4294967040;
              D.6861 = D.6860 >> 16;
              N = D.6861 & 8;
              N.78 = (int) N;
              Y = Y << N.78;
              D.6863 = Y + 4294963200;
              D.6864 = D.6863 >> 16;
              K = D.6864 & 4;
              N = N + K;
              K.79 = (int) K;
              Y = Y << K.79;
              D.6866 = Y + 4294950912;
              D.6867 = D.6866 >> 16;
              K = D.6867 & 2;
              K.80 = K;
              N = K.80 + N;
              K.79 = (int) K;
              Y = Y << K.79;
              D.6869 = Y >> 15;
              D.6870 = D.6869 - N;
              K = D.6870 + 14;
              D.6871 = K << 1;
              D.6872 = K + 7;
              D.6873 = (int) D.6872;
              D.6874 = psize >> D.6873;
              D.6875 = D.6874 & 1;
              I = D.6871 + D.6875;
            }
            <D.6859>:
            <D.6856>:
          }
          H = &m->treebins[I];
          tp->index = I;
          tp->child[1] = 0B;
          D.6876 = tp->child[1];
          tp->child[0] = D.6876;
          D.6808 = m->treemap;
          I.81 = (int) I;
          D.6878 = 1 << I.81;
          D.6879 = D.6808 & D.6878;
          if (D.6879 == 0) goto <D.6880>; else goto <D.6881>;
          <D.6880>:
          D.6808 = m->treemap;
          I.81 = (int) I;
          D.6878 = 1 << I.81;
          D.6882 = D.6808 | D.6878;
          m->treemap = D.6882;
          *H = tp;
          tp->parent = H;
          tp->bk = tp;
          D.6778 = tp->bk;
          tp->fd = D.6778;
          goto <D.6883>;
          <D.6881>:
          {
            struct malloc_tree_chunk * T;
            size_t K;

            T = *H;
            if (I != 31) goto <D.6885>; else goto <D.6886>;
            <D.6885>:
            D.6887 = I >> 1;
            D.6888 = 25 - D.6887;
            iftmp.82 = (int) D.6888;
            goto <D.6889>;
            <D.6886>:
            iftmp.82 = 0;
            <D.6889>:
            K = psize << iftmp.82;
            <D.4975>:
            D.6890 = T->head;
            D.6891 = D.6890 & 4294967292;
            if (D.6891 != psize) goto <D.6892>; else goto <D.6893>;
            <D.6892>:
            {
              struct malloc_tree_chunk * * C;

              D.6894 = K >> 31;
              C = &T->child[D.6894];
              K = K << 1;
              D.6895 = *C;
              if (D.6895 != 0B) goto <D.6896>; else goto <D.6897>;
              <D.6896>:
              T = *C;
              goto <D.6898>;
              <D.6897>:
              D.6781 = m->least_addr;
              D.6899 = D.6781 <= C;
              D.6900 = (long int) D.6899;
              D.6901 = __builtin_expect (D.6900, 1);
              if (D.6901 != 0) goto <D.6902>; else goto <D.6903>;
              <D.6902>:
              *C = tp;
              tp->parent = T;
              tp->bk = tp;
              D.6778 = tp->bk;
              tp->fd = D.6778;
              goto <D.4973>;
              <D.6903>:
              abort ();
              <D.6898>:
            }
            goto <D.6904>;
            <D.6893>:
            {
              struct malloc_tree_chunk * F;

              F = T->fd;
              D.6781 = m->least_addr;
              D.6906 = D.6781 <= T;
              D.6907 = (long int) D.6906;
              D.6908 = __builtin_expect (D.6907, 1);
              if (D.6908 != 0) goto <D.6909>; else goto <D.6905>;
              <D.6909>:
              D.6781 = m->least_addr;
              D.6910 = D.6781 <= F;
              D.6911 = (long int) D.6910;
              D.6912 = __builtin_expect (D.6911, 1);
              if (D.6912 != 0) goto <D.6913>; else goto <D.6905>;
              <D.6913>:
              F->bk = tp;
              D.6914 = F->bk;
              T->fd = D.6914;
              tp->fd = F;
              tp->bk = T;
              tp->parent = 0B;
              goto <D.4973>;
              <D.6905>:
              abort ();
            }
            <D.6904>:
            goto <D.4975>;
            <D.4973>:
          }
          <D.6883>:
        }
        <D.6853>:
      }
      <D.6773>:
      <D.6768>:
    }
    <D.6756>:
    pred = sp;
    sp = next;
  }
  <D.4977>:
  if (sp != 0B) goto <D.4976>; else goto <D.4978>;
  <D.4978>:
  D.6915 = released;
  return D.6915;
}


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

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


internal_memalign (struct malloc_state * m, size_t alignment, size_t bytes)
{
  void * D.6921;
  unsigned int D.6924;
  unsigned int D.6925;
  unsigned int D.6928;
  int * D.6933;
  unsigned int iftmp.83;
  unsigned int D.6938;
  unsigned int D.6940;
  unsigned int D.6946;
  int D.6948;
  unsigned int D.6949;
  unsigned int D.6950;
  union pthread_mutex_t * D.6951;
  int D.6952;
  unsigned int mem.84;
  unsigned int D.6956;
  sizetype D.6959;
  char * D.6960;
  unsigned int D.6961;
  unsigned int D.6962;
  unsigned int D.6963;
  sizetype D.6964;
  char * iftmp.85;
  int br.86;
  int p.87;
  int D.6968;
  unsigned int D.6969;
  int pos.88;
  int D.6974;
  unsigned int D.6975;
  unsigned int D.6976;
  unsigned int D.6979;
  unsigned int D.6981;
  unsigned int D.6982;
  unsigned int D.6984;
  unsigned int D.6985;
  unsigned int D.6986;
  unsigned int D.6987;
  unsigned int D.6988;
  unsigned int D.6989;
  struct malloc_chunk * D.6990;
  unsigned int D.6991;
  unsigned int D.6992;
  unsigned int D.6993;
  unsigned int D.6994;
  struct malloc_chunk * D.6995;
  unsigned int D.6996;
  unsigned int D.6997;
  unsigned int D.7001;
  unsigned int D.7004;
  unsigned int D.7005;
  struct malloc_chunk * D.7006;
  unsigned int D.7007;
  unsigned int D.7008;
  unsigned int D.7009;
  unsigned int D.7010;
  unsigned int D.7011;
  unsigned int D.7012;
  struct malloc_chunk * D.7013;
  unsigned int D.7014;
  unsigned int D.7015;

  if (alignment <= 8) goto <D.6919>; else goto <D.6920>;
  <D.6919>:
  D.6921 = dlmalloc (bytes);
  return D.6921;
  <D.6920>:
  if (alignment <= 15) goto <D.6922>; else goto <D.6923>;
  <D.6922>:
  alignment = 16;
  <D.6923>:
  D.6924 = alignment + 4294967295;
  D.6925 = D.6924 & alignment;
  if (D.6925 != 0) goto <D.6926>; else goto <D.6927>;
  <D.6926>:
  {
    size_t a;

    a = 16;
    goto <D.5087>;
    <D.5086>:
    a = a << 1;
    <D.5087>:
    if (a < alignment) goto <D.5086>; else goto <D.5088>;
    <D.5088>:
    alignment = a;
  }
  <D.6927>:
  D.6928 = 4294967232 - alignment;
  if (D.6928 <= bytes) goto <D.6929>; else goto <D.6930>;
  <D.6929>:
  if (m != 0B) goto <D.6931>; else goto <D.6932>;
  <D.6931>:
  D.6933 = __errno_location ();
  *D.6933 = 12;
  <D.6932>:
  goto <D.6934>;
  <D.6930>:
  {
    size_t nb;
    size_t req;
    char * mem;

    if (bytes > 10) goto <D.6936>; else goto <D.6937>;
    <D.6936>:
    D.6938 = bytes + 11;
    iftmp.83 = D.6938 & 4294967288;
    goto <D.6939>;
    <D.6937>:
    iftmp.83 = 16;
    <D.6939>:
    nb = iftmp.83;
    D.6940 = nb + alignment;
    req = D.6940 + 12;
    mem = dlmalloc (req);
    if (mem != 0B) goto <D.6941>; else goto <D.6942>;
    <D.6941>:
    {
      void * leader;
      void * trailer;
      struct malloc_chunk * p;

      leader = 0B;
      trailer = 0B;
      p = mem + 4294967288;
      D.6946 = mparams.page_size;
      if (D.6946 == 0) goto <D.6947>; else goto <D.6943>;
      <D.6947>:
      D.6948 = init_mparams ();
      if (D.6948 != 0) goto <D.6944>; else goto <D.6943>;
      <D.6943>:
      D.6949 = m->mflags;
      D.6950 = D.6949 & 2;
      if (D.6950 != 0) goto <D.6944>; else goto <D.6945>;
      <D.6944>:
      D.6951 = &m->mutex;
      D.6952 = pthread_mutex_lock (D.6951);
      if (D.6952 != 0) goto <D.6953>; else goto <D.6954>;
      <D.6953>:
      D.6921 = 0B;
      return D.6921;
      <D.6954>:
      <D.6945>:
      mem.84 = (unsigned int) mem;
      D.6956 = mem.84 % alignment;
      if (D.6956 != 0) goto <D.6957>; else goto <D.6958>;
      <D.6957>:
      {
        char * br;
        char * pos;
        struct malloc_chunk * newp;
        size_t leadsize;
        size_t newsize;

        D.6959 = alignment + 4294967295;
        D.6960 = mem + D.6959;
        D.6961 = (unsigned int) D.6960;
        D.6962 = -alignment;
        D.6963 = D.6961 & D.6962;
        D.6964 = D.6963 + 4294967288;
        br = (char *) D.6964;
        br.86 = (int) br;
        p.87 = (int) p;
        D.6968 = br.86 - p.87;
        D.6969 = (unsigned int) D.6968;
        if (D.6969 <= 15) goto <D.6970>; else goto <D.6971>;
        <D.6970>:
        iftmp.85 = br + alignment;
        goto <D.6972>;
        <D.6971>:
        iftmp.85 = br;
        <D.6972>:
        pos = iftmp.85;
        newp = pos;
        pos.88 = (int) pos;
        p.87 = (int) p;
        D.6974 = pos.88 - p.87;
        leadsize = (size_t) D.6974;
        D.6975 = p->head;
        D.6976 = D.6975 & 4294967292;
        newsize = D.6976 - leadsize;
        D.6975 = p->head;
        D.6979 = D.6975 & 1;
        if (D.6979 == 0) goto <D.6980>; else goto <D.6977>;
        <D.6980>:
        D.6981 = p->prev_foot;
        D.6982 = D.6981 & 1;
        if (D.6982 != 0) goto <D.6983>; else goto <D.6977>;
        <D.6983>:
        D.6981 = p->prev_foot;
        D.6984 = D.6981 + leadsize;
        newp->prev_foot = D.6984;
        D.6985 = newsize | 2;
        newp->head = D.6985;
        goto <D.6978>;
        <D.6977>:
        D.6986 = newp->head;
        D.6987 = D.6986 & 1;
        D.6988 = D.6987 | newsize;
        D.6989 = D.6988 | 2;
        newp->head = D.6989;
        D.6990 = newp + newsize;
        D.6990 = newp + newsize;
        D.6991 = D.6990->head;
        D.6992 = D.6991 | 1;
        D.6990->head = D.6992;
        D.6975 = p->head;
        D.6979 = D.6975 & 1;
        D.6993 = D.6979 | leadsize;
        D.6994 = D.6993 | 2;
        p->head = D.6994;
        D.6995 = p + leadsize;
        D.6995 = p + leadsize;
        D.6996 = D.6995->head;
        D.6997 = D.6996 | 1;
        D.6995->head = D.6997;
        leader = p + 8;
        <D.6978>:
        p = newp;
      }
      <D.6958>:
      D.6975 = p->head;
      D.6979 = D.6975 & 1;
      if (D.6979 != 0) goto <D.6998>; else goto <D.7000>;
      <D.7000>:
      D.6981 = p->prev_foot;
      D.6982 = D.6981 & 1;
      if (D.6982 == 0) goto <D.6998>; else goto <D.6999>;
      <D.6998>:
      {
        size_t size;

        D.6975 = p->head;
        size = D.6975 & 4294967292;
        D.7001 = nb + 16;
        if (D.7001 < size) goto <D.7002>; else goto <D.7003>;
        <D.7002>:
        {
          size_t remainder_size;
          struct malloc_chunk * remainder;

          remainder_size = size - nb;
          remainder = p + nb;
          D.6975 = p->head;
          D.6979 = D.6975 & 1;
          D.7004 = D.6979 | nb;
          D.7005 = D.7004 | 2;
          p->head = D.7005;
          D.7006 = p + nb;
          D.7006 = p + nb;
          D.7007 = D.7006->head;
          D.7008 = D.7007 | 1;
          D.7006->head = D.7008;
          D.7009 = remainder->head;
          D.7010 = D.7009 & 1;
          D.7011 = D.7010 | remainder_size;
          D.7012 = D.7011 | 2;
          remainder->head = D.7012;
          D.7013 = remainder + remainder_size;
          D.7013 = remainder + remainder_size;
          D.7014 = D.7013->head;
          D.7015 = D.7014 | 1;
          D.7013->head = D.7015;
          trailer = remainder + 8;
        }
        <D.7003>:
      }
      <D.6999>:
      D.6949 = m->mflags;
      D.6950 = D.6949 & 2;
      if (D.6950 != 0) goto <D.7016>; else goto <D.7017>;
      <D.7016>:
      D.6951 = &m->mutex;
      pthread_mutex_unlock (D.6951);
      <D.7017>:
      if (leader != 0B) goto <D.7018>; else goto <D.7019>;
      <D.7018>:
      dlfree (leader);
      <D.7019>:
      if (trailer != 0B) goto <D.7020>; else goto <D.7021>;
      <D.7020>:
      dlfree (trailer);
      <D.7021>:
      D.6921 = p + 8;
      return D.6921;
    }
    <D.6942>:
  }
  <D.6934>:
  D.6921 = 0B;
  return D.6921;
}