dlmalloc (size_t bytes)
{
  unsigned int D.5224;
  int D.5226;
  unsigned int D.5227;
  unsigned int D.5228;
  int D.5229;
  unsigned int iftmp.0;
  unsigned int D.5235;
  unsigned int D.5237;
  int idx.1;
  unsigned int D.5239;
  unsigned int D.5242;
  _Bool D.5243;
  unsigned int D.5244;
  unsigned int D.5245;
  unsigned int D.5248;
  unsigned int D.5249;
  unsigned int D.5250;
  char * D.5252;
  _Bool D.5253;
  long int D.5254;
  long int D.5255;
  unsigned int D.5259;
  unsigned int D.5260;
  struct malloc_chunk * D.5261;
  unsigned int D.5262;
  unsigned int D.5263;
  unsigned int D.5264;
  unsigned int D.5269;
  unsigned int D.5270;
  unsigned int D.5271;
  unsigned int D.5272;
  unsigned int D.5273;
  unsigned int D.5274;
  int i.2;
  unsigned int D.5278;
  unsigned int D.5279;
  unsigned int D.5280;
  _Bool D.5282;
  long int D.5283;
  long int D.5284;
  unsigned int D.5288;
  unsigned int D.5291;
  struct malloc_chunk * D.5292;
  unsigned int D.5293;
  unsigned int D.5294;
  unsigned int D.5296;
  unsigned int D.5297;
  struct malloc_chunk * D.5298;
  unsigned int D.5301;
  int I.3;
  unsigned int D.5303;
  unsigned int D.5304;
  unsigned int D.5307;
  struct malloc_chunk * D.5309;
  _Bool D.5310;
  long int D.5311;
  long int D.5312;
  unsigned int D.5316;
  struct malloc_chunk * D.5331;
  unsigned int D.5332;
  struct malloc_chunk * D.5333;
  unsigned int D.5335;
  struct malloc_chunk * D.5336;
  unsigned int D.5337;
  unsigned int D.5338;
  unsigned int D.5339;
  unsigned int D.5342;
  struct malloc_chunk * D.5343;
  unsigned int D.5344;
  void * D.5347;
  void postaction = <<< error >>>;

  D.5224 = mparams.page_size;
  if (D.5224 != 0) goto <D.5220>; else goto <D.5225>;
  <D.5225>:
  D.5226 = init_mparams ();
  if (D.5226 == 0) goto <D.5220>; else goto <D.5221>;
  <D.5220>:
  D.5227 = _gm_.mflags;
  D.5228 = D.5227 & 2;
  if (D.5228 == 0) goto <D.5222>; else goto <D.5221>;
  <D.5221>:
  D.5229 = pthread_mutex_lock (&_gm_.mutex);
  if (D.5229 == 0) goto <D.5222>; else goto <D.5223>;
  <D.5222>:
  {
    void * mem;
    size_t nb;

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

      if (bytes > 10) goto <D.5233>; else goto <D.5234>;
      <D.5233>:
      D.5235 = bytes + 11;
      iftmp.0 = D.5235 & 4294967288;
      goto <D.5236>;
      <D.5234>:
      iftmp.0 = 16;
      <D.5236>:
      nb = iftmp.0;
      idx = nb >> 3;
      D.5237 = _gm_.smallmap;
      idx.1 = (int) idx;
      smallbits = D.5237 >> idx.1;
      D.5239 = smallbits & 3;
      if (D.5239 != 0) goto <D.5240>; else goto <D.5241>;
      <D.5240>:
      {
        struct malloc_chunk * b;
        struct malloc_chunk * p;

        D.5242 = smallbits & 1;
        D.5243 = D.5242 == 0;
        D.5244 = (unsigned int) D.5243;
        idx = D.5244 + idx;
        D.5245 = idx << 1;
        b = &_gm_.smallbins[D.5245];
        p = b->fd;
        {
          struct malloc_chunk * F;

          F = p->fd;
          if (b == F) goto <D.5246>; else goto <D.5247>;
          <D.5246>:
          D.5237 = _gm_.smallmap;
          idx.1 = (int) idx;
          D.5248 = 1 << idx.1;
          D.5249 = ~D.5248;
          D.5250 = D.5237 & D.5249;
          _gm_.smallmap = D.5250;
          goto <D.5251>;
          <D.5247>:
          D.5252 = _gm_.least_addr;
          D.5253 = D.5252 <= F;
          D.5254 = (long int) D.5253;
          D.5255 = __builtin_expect (D.5254, 1);
          if (D.5255 != 0) goto <D.5256>; else goto <D.5257>;
          <D.5256>:
          b->fd = F;
          F->bk = b;
          goto <D.5258>;
          <D.5257>:
          abort ();
          <D.5258>:
          <D.5251>:
        }
        D.5259 = idx << 3;
        D.5260 = D.5259 | 3;
        p->head = D.5260;
        D.5259 = idx << 3;
        D.5261 = p + D.5259;
        D.5259 = idx << 3;
        D.5261 = p + D.5259;
        D.5262 = D.5261->head;
        D.5263 = D.5262 | 1;
        D.5261->head = D.5263;
        mem = p + 8;
        goto postaction;
      }
      <D.5241>:
      D.5264 = _gm_.dvsize;
      if (D.5264 < nb) goto <D.5265>; else goto <D.5266>;
      <D.5265>:
      if (smallbits != 0) goto <D.5267>; else goto <D.5268>;
      <D.5267>:
      {
        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.5269 = smallbits << idx.1;
        idx.1 = (int) idx;
        D.5248 = 1 << idx.1;
        D.5270 = D.5248 << 1;
        idx.1 = (int) idx;
        D.5248 = 1 << idx.1;
        D.5270 = D.5248 << 1;
        D.5271 = -D.5270;
        D.5272 = D.5270 | D.5271;
        leftbits = D.5269 & D.5272;
        D.5273 = -leftbits;
        leastbit = D.5273 & leftbits;
        {
          unsigned int J;

          __asm__("bsfl %1,%0
	" : "=r" J : "rm" leastbit);
          i = J;
        }
        D.5274 = i << 1;
        b = &_gm_.smallbins[D.5274];
        p = b->fd;
        {
          struct malloc_chunk * F;

          F = p->fd;
          if (b == F) goto <D.5275>; else goto <D.5276>;
          <D.5275>:
          D.5237 = _gm_.smallmap;
          i.2 = (int) i;
          D.5278 = 1 << i.2;
          D.5279 = ~D.5278;
          D.5280 = D.5237 & D.5279;
          _gm_.smallmap = D.5280;
          goto <D.5281>;
          <D.5276>:
          D.5252 = _gm_.least_addr;
          D.5282 = D.5252 <= F;
          D.5283 = (long int) D.5282;
          D.5284 = __builtin_expect (D.5283, 1);
          if (D.5284 != 0) goto <D.5285>; else goto <D.5286>;
          <D.5285>:
          b->fd = F;
          F->bk = b;
          goto <D.5287>;
          <D.5286>:
          abort ();
          <D.5287>:
          <D.5281>:
        }
        D.5288 = i << 3;
        rsize = D.5288 - nb;
        if (0 != 0) goto <D.5289>; else goto <D.5290>;
        <D.5289>:
        D.5288 = i << 3;
        D.5291 = D.5288 | 3;
        p->head = D.5291;
        D.5288 = i << 3;
        D.5292 = p + D.5288;
        D.5288 = i << 3;
        D.5292 = p + D.5288;
        D.5293 = D.5292->head;
        D.5294 = D.5293 | 1;
        D.5292->head = D.5294;
        goto <D.5295>;
        <D.5290>:
        D.5296 = nb | 3;
        p->head = D.5296;
        r = p + nb;
        D.5297 = rsize | 1;
        r->head = D.5297;
        D.5298 = r + rsize;
        D.5298->prev_foot = rsize;
        {
          size_t DVS;

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

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

              I = DVS >> 3;
              D.5301 = I << 1;
              B = &_gm_.smallbins[D.5301];
              F = B;
              D.5237 = _gm_.smallmap;
              I.3 = (int) I;
              D.5303 = 1 << I.3;
              D.5304 = D.5237 & D.5303;
              if (D.5304 == 0) goto <D.5305>; else goto <D.5306>;
              <D.5305>:
              D.5237 = _gm_.smallmap;
              I.3 = (int) I;
              D.5303 = 1 << I.3;
              D.5307 = D.5237 | D.5303;
              _gm_.smallmap = D.5307;
              goto <D.5308>;
              <D.5306>:
              D.5309 = B->fd;
              D.5252 = _gm_.least_addr;
              D.5310 = D.5309 >= D.5252;
              D.5311 = (long int) D.5310;
              D.5312 = __builtin_expect (D.5311, 1);
              if (D.5312 != 0) goto <D.5313>; else goto <D.5314>;
              <D.5313>:
              F = B->fd;
              goto <D.5315>;
              <D.5314>:
              abort ();
              <D.5315>:
              <D.5308>:
              B->fd = DV;
              F->bk = DV;
              DV->fd = F;
              DV->bk = B;
            }
          }
          <D.5300>:
          _gm_.dvsize = rsize;
          _gm_.dv = r;
        }
        <D.5295>:
        mem = p + 8;
        goto postaction;
      }
      <D.5268>:
      D.5316 = _gm_.treemap;
      if (D.5316 != 0) goto <D.5317>; else goto <D.5318>;
      <D.5317>:
      mem = tmalloc_small (&_gm_, nb);
      if (mem != 0B) goto postaction; else goto <D.5319>;
      <D.5319>:
      <D.5318>:
      <D.5266>:
    }
    goto <D.5320>;
    <D.5231>:
    if (bytes > 4294967231) goto <D.5321>; else goto <D.5322>;
    <D.5321>:
    nb = 4294967295;
    goto <D.5323>;
    <D.5322>:
    D.5235 = bytes + 11;
    nb = D.5235 & 4294967288;
    D.5316 = _gm_.treemap;
    if (D.5316 != 0) goto <D.5324>; else goto <D.5325>;
    <D.5324>:
    mem = tmalloc_large (&_gm_, nb);
    if (mem != 0B) goto postaction; else goto <D.5326>;
    <D.5326>:
    <D.5325>:
    <D.5323>:
    <D.5320>:
    D.5264 = _gm_.dvsize;
    if (D.5264 >= nb) goto <D.5327>; else goto <D.5328>;
    <D.5327>:
    {
      size_t rsize;
      struct malloc_chunk * p;

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

        D.5331 = p + nb;
        _gm_.dv = D.5331;
        r = _gm_.dv;
        _gm_.dvsize = rsize;
        D.5332 = rsize | 1;
        r->head = D.5332;
        D.5333 = r + rsize;
        D.5333->prev_foot = rsize;
        D.5296 = nb | 3;
        p->head = D.5296;
      }
      goto <D.5334>;
      <D.5330>:
      {
        size_t dvs;

        dvs = _gm_.dvsize;
        _gm_.dvsize = 0;
        _gm_.dv = 0B;
        D.5335 = dvs | 3;
        p->head = D.5335;
        D.5336 = p + dvs;
        D.5336 = p + dvs;
        D.5337 = D.5336->head;
        D.5338 = D.5337 | 1;
        D.5336->head = D.5338;
      }
      <D.5334>:
      mem = p + 8;
      goto postaction;
    }
    <D.5328>:
    D.5339 = _gm_.topsize;
    if (D.5339 > nb) goto <D.5340>; else goto <D.5341>;
    <D.5340>:
    {
      size_t rsize;
      struct malloc_chunk * p;
      struct malloc_chunk * r;

      D.5339 = _gm_.topsize;
      D.5342 = D.5339 - nb;
      _gm_.topsize = D.5342;
      rsize = _gm_.topsize;
      p = _gm_.top;
      D.5343 = p + nb;
      _gm_.top = D.5343;
      r = _gm_.top;
      D.5344 = rsize | 1;
      r->head = D.5344;
      D.5296 = nb | 3;
      p->head = D.5296;
      mem = p + 8;
      goto postaction;
    }
    <D.5341>:
    mem = sys_alloc (&_gm_, nb);
    postaction:
    D.5227 = _gm_.mflags;
    D.5228 = D.5227 & 2;
    if (D.5228 != 0) goto <D.5345>; else goto <D.5346>;
    <D.5345>:
    pthread_mutex_unlock (&_gm_.mutex);
    <D.5346>:
    D.5347 = mem;
    return D.5347;
  }
  <D.5223>:
  D.5347 = 0B;
  return D.5347;
}


init_mparams ()
{
  unsigned int D.5349;
  unsigned int D.5352;
  unsigned int D.5355;
  unsigned int D.5358;
  unsigned int D.5359;
  unsigned int D.5360;
  unsigned int D.5362;
  unsigned int D.5363;
  int D.5364;

  D.5349 = mparams.page_size;
  if (D.5349 == 0) goto <D.5350>; else goto <D.5351>;
  <D.5350>:
  {
    size_t s;

    mparams.mmap_threshold = 262144;
    mparams.trim_threshold = 2097152;
    mparams.default_mflags = 7;
    s = 1482184792;
    pthread_mutex_lock (&magic_init_mutex);
    D.5352 = mparams.magic;
    if (D.5352 == 0) goto <D.5353>; else goto <D.5354>;
    <D.5353>:
    mparams.magic = s;
    pthread_mutex_init (&_gm_.mutex, 0B);
    D.5355 = mparams.default_mflags;
    _gm_.mflags = D.5355;
    <D.5354>:
    pthread_mutex_unlock (&magic_init_mutex);
    mparams.page_size = 4096;
    mparams.granularity = 65536;
    D.5358 = mparams.granularity;
    D.5358 = mparams.granularity;
    D.5359 = D.5358 + 4294967295;
    D.5360 = D.5358 & D.5359;
    if (D.5360 != 0) goto <D.5356>; else goto <D.5361>;
    <D.5361>:
    D.5349 = mparams.page_size;
    D.5349 = mparams.page_size;
    D.5362 = D.5349 + 4294967295;
    D.5363 = D.5349 & D.5362;
    if (D.5363 != 0) goto <D.5356>; else goto <D.5357>;
    <D.5356>:
    abort ();
    <D.5357>:
  }
  <D.5351>:
  D.5364 = 0;
  return D.5364;
}


tmalloc_small (struct malloc_state * m, size_t nb)
{
  unsigned int D.5366;
  unsigned int D.5367;
  unsigned int D.5368;
  unsigned int D.5369;
  struct malloc_tree_chunk * iftmp.4;
  struct malloc_tree_chunk * D.5373;
  char * D.5377;
  _Bool D.5378;
  long int D.5379;
  long int D.5380;
  _Bool D.5383;
  long int D.5384;
  long int D.5385;
  struct malloc_tree_chunk * D.5388;
  _Bool D.5391;
  long int D.5392;
  long int D.5393;
  struct malloc_tree_chunk * D.5401;
  _Bool D.5403;
  long int D.5404;
  long int D.5405;
  unsigned int D.5411;
  struct malloc_tree_chunk * D.5412;
  int D.5417;
  unsigned int D.5418;
  unsigned int D.5419;
  unsigned int D.5420;
  _Bool D.5422;
  long int D.5423;
  long int D.5424;
  struct malloc_tree_chunk * D.5427;
  _Bool D.5434;
  long int D.5435;
  long int D.5436;
  _Bool D.5441;
  long int D.5442;
  long int D.5443;
  _Bool D.5449;
  long int D.5450;
  long int D.5451;
  unsigned int D.5458;
  unsigned int D.5459;
  struct malloc_chunk * D.5460;
  unsigned int D.5461;
  unsigned int D.5462;
  unsigned int D.5464;
  unsigned int D.5465;
  struct malloc_chunk * D.5466;
  unsigned int D.5469;
  unsigned int D.5470;
  int I.5;
  unsigned int D.5472;
  unsigned int D.5473;
  unsigned int D.5476;
  struct malloc_chunk * D.5478;
  _Bool D.5479;
  long int D.5480;
  long int D.5481;
  void * D.5485;
  struct malloc_tree_chunk * t;
  struct malloc_tree_chunk * v;
  size_t rsize;
  bindex_t i;
  binmap_t leastbit;

  D.5366 = m->treemap;
  D.5366 = m->treemap;
  D.5367 = -D.5366;
  leastbit = D.5366 & D.5367;
  {
    unsigned int J;

    __asm__("bsfl %1,%0
	" : "=r" J : "rm" leastbit);
    i = J;
  }
  t = m->treebins[i];
  v = t;
  D.5368 = t->head;
  D.5369 = D.5368 & 4294967292;
  rsize = D.5369 - nb;
  goto <D.5084>;
  <D.5083>:
  {
    size_t trem;

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

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

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

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

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

          goto <D.5093>;
          <D.5092>:
          RP = CP;
          R = *RP;
          <D.5093>:
          CP = &R->child[1];
          D.5401 = *CP;
          if (D.5401 != 0B) goto <D.5092>; else goto <D.5402>;
          <D.5402>:
          CP = &R->child[0];
          D.5401 = *CP;
          if (D.5401 != 0B) goto <D.5092>; else goto <D.5094>;
          <D.5094>:
          D.5377 = m->least_addr;
          D.5403 = D.5377 <= RP;
          D.5404 = (long int) D.5403;
          D.5405 = __builtin_expect (D.5404, 1);
          if (D.5405 != 0) goto <D.5406>; else goto <D.5407>;
          <D.5406>:
          *RP = 0B;
          goto <D.5408>;
          <D.5407>:
          abort ();
          <D.5408>:
        }
        <D.5399>:
      }
      <D.5397>:
      if (XP != 0B) goto <D.5409>; else goto <D.5410>;
      <D.5409>:
      {
        struct malloc_tree_chunk * * H;

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

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

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

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

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


tmalloc_large (struct malloc_state * m, size_t nb)
{
  unsigned int D.5493;
  unsigned int D.5494;
  int D.5495;
  unsigned int D.5496;
  unsigned int D.5497;
  int iftmp.6;
  unsigned int D.5503;
  unsigned int D.5504;
  unsigned int D.5506;
  unsigned int D.5507;
  unsigned int D.5511;
  _Bool D.5512;
  _Bool D.5513;
  _Bool D.5514;
  _Bool D.5519;
  _Bool D.5520;
  _Bool D.5521;
  int idx.7;
  unsigned int D.5525;
  unsigned int D.5526;
  unsigned int D.5527;
  unsigned int D.5528;
  unsigned int D.5529;
  unsigned int D.5532;
  struct malloc_tree_chunk * iftmp.8;
  struct malloc_tree_chunk * D.5536;
  unsigned int D.5542;
  unsigned int D.5543;
  char * D.5546;
  _Bool D.5547;
  long int D.5548;
  long int D.5549;
  _Bool D.5552;
  long int D.5553;
  long int D.5554;
  struct malloc_tree_chunk * D.5557;
  _Bool D.5560;
  long int D.5561;
  long int D.5562;
  struct malloc_tree_chunk * D.5570;
  _Bool D.5572;
  long int D.5573;
  long int D.5574;
  unsigned int D.5580;
  struct malloc_tree_chunk * D.5581;
  int D.5586;
  unsigned int D.5587;
  unsigned int D.5588;
  unsigned int D.5589;
  _Bool D.5591;
  long int D.5592;
  long int D.5593;
  struct malloc_tree_chunk * D.5596;
  _Bool D.5603;
  long int D.5604;
  long int D.5605;
  _Bool D.5610;
  long int D.5611;
  long int D.5612;
  _Bool D.5618;
  long int D.5619;
  long int D.5620;
  unsigned int D.5627;
  unsigned int D.5628;
  struct malloc_chunk * D.5629;
  unsigned int D.5630;
  unsigned int D.5631;
  unsigned int D.5633;
  unsigned int D.5634;
  struct malloc_chunk * D.5635;
  unsigned int D.5636;
  unsigned int D.5639;
  unsigned int D.5640;
  int I.9;
  unsigned int D.5642;
  unsigned int D.5643;
  unsigned int D.5646;
  struct malloc_chunk * D.5648;
  _Bool D.5649;
  long int D.5650;
  long int D.5651;
  unsigned int D.5662;
  unsigned int D.5663;
  int D.5664;
  unsigned int D.5665;
  unsigned int D.5666;
  struct malloc_tree_chunk * D.5667;
  int I.10;
  unsigned int D.5669;
  unsigned int D.5670;
  unsigned int D.5673;
  struct malloc_tree_chunk * D.5674;
  int iftmp.11;
  unsigned int D.5679;
  unsigned int D.5680;
  unsigned int D.5682;
  unsigned int D.5683;
  unsigned int D.5686;
  struct malloc_tree_chunk * D.5687;
  _Bool D.5691;
  long int D.5692;
  long int D.5693;
  _Bool D.5698;
  long int D.5699;
  long int D.5700;
  _Bool D.5702;
  long int D.5703;
  long int D.5704;
  struct malloc_tree_chunk * D.5706;
  void * D.5707;
  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.5487>; else goto <D.5488>;
    <D.5487>:
    idx = 0;
    goto <D.5489>;
    <D.5488>:
    if (X > 65535) goto <D.5490>; else goto <D.5491>;
    <D.5490>:
    idx = 31;
    goto <D.5492>;
    <D.5491>:
    {
      unsigned int K;

      __asm__("bsrl %1,%0
	" : "=r" K : "rm" X);
      D.5493 = K << 1;
      D.5494 = K + 7;
      D.5495 = (int) D.5494;
      D.5496 = nb >> D.5495;
      D.5497 = D.5496 & 1;
      idx = D.5493 + D.5497;
    }
    <D.5492>:
    <D.5489>:
  }
  t = m->treebins[idx];
  if (t != 0B) goto <D.5498>; else goto <D.5499>;
  <D.5498>:
  {
    size_t sizebits;
    struct malloc_tree_chunk * rst;

    if (idx != 31) goto <D.5501>; else goto <D.5502>;
    <D.5501>:
    D.5503 = idx >> 1;
    D.5504 = 25 - D.5503;
    iftmp.6 = (int) D.5504;
    goto <D.5505>;
    <D.5502>:
    iftmp.6 = 0;
    <D.5505>:
    sizebits = nb << iftmp.6;
    rst = 0B;
    <D.5037>:
    {
      struct malloc_tree_chunk * rt;
      size_t trem;

      D.5506 = t->head;
      D.5507 = D.5506 & 4294967292;
      trem = D.5507 - nb;
      if (trem < rsize) goto <D.5508>; else goto <D.5509>;
      <D.5508>:
      v = t;
      rsize = trem;
      if (rsize == 0) goto <D.5036>; else goto <D.5510>;
      <D.5510>:
      <D.5509>:
      rt = t->child[1];
      D.5511 = sizebits >> 31;
      t = t->child[D.5511];
      D.5512 = rt != 0B;
      D.5513 = rt != t;
      D.5514 = D.5512 & D.5513;
      if (D.5514 != 0) goto <D.5515>; else goto <D.5516>;
      <D.5515>:
      rst = rt;
      <D.5516>:
      if (t == 0B) goto <D.5517>; else goto <D.5518>;
      <D.5517>:
      t = rst;
      goto <D.5036>;
      <D.5518>:
      sizebits = sizebits << 1;
    }
    goto <D.5037>;
    <D.5036>:
  }
  <D.5499>:
  D.5519 = t == 0B;
  D.5520 = v == 0B;
  D.5521 = D.5519 & D.5520;
  if (D.5521 != 0) goto <D.5522>; else goto <D.5523>;
  <D.5522>:
  {
    binmap_t leftbits;

    idx.7 = (int) idx;
    D.5525 = 1 << idx.7;
    D.5526 = D.5525 << 1;
    idx.7 = (int) idx;
    D.5525 = 1 << idx.7;
    D.5526 = D.5525 << 1;
    D.5527 = -D.5526;
    D.5528 = D.5526 | D.5527;
    D.5529 = m->treemap;
    leftbits = D.5528 & D.5529;
    if (leftbits != 0) goto <D.5530>; else goto <D.5531>;
    <D.5530>:
    {
      bindex_t i;
      binmap_t leastbit;

      D.5532 = -leftbits;
      leastbit = D.5532 & leftbits;
      {
        unsigned int J;

        __asm__("bsfl %1,%0
	" : "=r" J : "rm" leastbit);
        i = J;
      }
      t = m->treebins[i];
    }
    <D.5531>:
  }
  <D.5523>:
  goto <D.5044>;
  <D.5043>:
  {
    size_t trem;

    D.5506 = t->head;
    D.5507 = D.5506 & 4294967292;
    trem = D.5507 - nb;
    if (trem < rsize) goto <D.5533>; else goto <D.5534>;
    <D.5533>:
    rsize = trem;
    v = t;
    <D.5534>:
    D.5536 = t->child[0];
    if (D.5536 != 0B) goto <D.5537>; else goto <D.5538>;
    <D.5537>:
    iftmp.8 = t->child[0];
    goto <D.5539>;
    <D.5538>:
    iftmp.8 = t->child[1];
    <D.5539>:
    t = iftmp.8;
  }
  <D.5044>:
  if (t != 0B) goto <D.5043>; else goto <D.5045>;
  <D.5045>:
  if (v != 0B) goto <D.5540>; else goto <D.5541>;
  <D.5540>:
  D.5542 = m->dvsize;
  D.5543 = D.5542 - nb;
  if (D.5543 > rsize) goto <D.5544>; else goto <D.5545>;
  <D.5544>:
  D.5546 = m->least_addr;
  D.5547 = D.5546 <= v;
  D.5548 = (long int) D.5547;
  D.5549 = __builtin_expect (D.5548, 1);
  if (D.5549 != 0) goto <D.5550>; else goto <D.5551>;
  <D.5550>:
  {
    struct malloc_chunk * r;

    r = v + nb;
    D.5552 = v < r;
    D.5553 = (long int) D.5552;
    D.5554 = __builtin_expect (D.5553, 1);
    if (D.5554 != 0) goto <D.5555>; else goto <D.5556>;
    <D.5555>:
    {
      struct malloc_tree_chunk * XP;
      struct malloc_tree_chunk * R;

      XP = v->parent;
      D.5557 = v->bk;
      if (D.5557 != v) goto <D.5558>; else goto <D.5559>;
      <D.5558>:
      {
        struct malloc_tree_chunk * F;

        F = v->fd;
        R = v->bk;
        D.5546 = m->least_addr;
        D.5560 = D.5546 <= F;
        D.5561 = (long int) D.5560;
        D.5562 = __builtin_expect (D.5561, 1);
        if (D.5562 != 0) goto <D.5563>; else goto <D.5564>;
        <D.5563>:
        F->bk = R;
        R->fd = F;
        goto <D.5565>;
        <D.5564>:
        abort ();
        <D.5565>:
      }
      goto <D.5566>;
      <D.5559>:
      {
        struct malloc_tree_chunk * * RP;

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

          goto <D.5053>;
          <D.5052>:
          RP = CP;
          R = *RP;
          <D.5053>:
          CP = &R->child[1];
          D.5570 = *CP;
          if (D.5570 != 0B) goto <D.5052>; else goto <D.5571>;
          <D.5571>:
          CP = &R->child[0];
          D.5570 = *CP;
          if (D.5570 != 0B) goto <D.5052>; else goto <D.5054>;
          <D.5054>:
          D.5546 = m->least_addr;
          D.5572 = D.5546 <= RP;
          D.5573 = (long int) D.5572;
          D.5574 = __builtin_expect (D.5573, 1);
          if (D.5574 != 0) goto <D.5575>; else goto <D.5576>;
          <D.5575>:
          *RP = 0B;
          goto <D.5577>;
          <D.5576>:
          abort ();
          <D.5577>:
        }
        <D.5568>:
      }
      <D.5566>:
      if (XP != 0B) goto <D.5578>; else goto <D.5579>;
      <D.5578>:
      {
        struct malloc_tree_chunk * * H;

        D.5580 = v->index;
        H = &m->treebins[D.5580];
        D.5581 = *H;
        if (D.5581 == v) goto <D.5582>; else goto <D.5583>;
        <D.5582>:
        *H = R;
        D.5581 = *H;
        if (D.5581 == 0B) goto <D.5584>; else goto <D.5585>;
        <D.5584>:
        D.5529 = m->treemap;
        D.5580 = v->index;
        D.5586 = (int) D.5580;
        D.5587 = 1 << D.5586;
        D.5588 = ~D.5587;
        D.5589 = D.5529 & D.5588;
        m->treemap = D.5589;
        <D.5585>:
        goto <D.5590>;
        <D.5583>:
        D.5546 = m->least_addr;
        D.5591 = D.5546 <= XP;
        D.5592 = (long int) D.5591;
        D.5593 = __builtin_expect (D.5592, 1);
        if (D.5593 != 0) goto <D.5594>; else goto <D.5595>;
        <D.5594>:
        D.5596 = XP->child[0];
        if (D.5596 == v) goto <D.5597>; else goto <D.5598>;
        <D.5597>:
        XP->child[0] = R;
        goto <D.5599>;
        <D.5598>:
        XP->child[1] = R;
        <D.5599>:
        goto <D.5600>;
        <D.5595>:
        abort ();
        <D.5600>:
        <D.5590>:
        if (R != 0B) goto <D.5601>; else goto <D.5602>;
        <D.5601>:
        D.5546 = m->least_addr;
        D.5603 = D.5546 <= R;
        D.5604 = (long int) D.5603;
        D.5605 = __builtin_expect (D.5604, 1);
        if (D.5605 != 0) goto <D.5606>; else goto <D.5607>;
        <D.5606>:
        {
          struct malloc_tree_chunk * C0;
          struct malloc_tree_chunk * C1;

          R->parent = XP;
          C0 = v->child[0];
          if (C0 != 0B) goto <D.5608>; else goto <D.5609>;
          <D.5608>:
          D.5546 = m->least_addr;
          D.5610 = D.5546 <= C0;
          D.5611 = (long int) D.5610;
          D.5612 = __builtin_expect (D.5611, 1);
          if (D.5612 != 0) goto <D.5613>; else goto <D.5614>;
          <D.5613>:
          R->child[0] = C0;
          C0->parent = R;
          goto <D.5615>;
          <D.5614>:
          abort ();
          <D.5615>:
          <D.5609>:
          C1 = v->child[1];
          if (C1 != 0B) goto <D.5616>; else goto <D.5617>;
          <D.5616>:
          D.5546 = m->least_addr;
          D.5618 = D.5546 <= C1;
          D.5619 = (long int) D.5618;
          D.5620 = __builtin_expect (D.5619, 1);
          if (D.5620 != 0) goto <D.5621>; else goto <D.5622>;
          <D.5621>:
          R->child[1] = C1;
          C1->parent = R;
          goto <D.5623>;
          <D.5622>:
          abort ();
          <D.5623>:
          <D.5617>:
        }
        goto <D.5624>;
        <D.5607>:
        abort ();
        <D.5624>:
        <D.5602>:
      }
      <D.5579>:
    }
    if (rsize <= 15) goto <D.5625>; else goto <D.5626>;
    <D.5625>:
    D.5627 = rsize + nb;
    D.5628 = D.5627 | 3;
    v->head = D.5628;
    D.5627 = rsize + nb;
    D.5629 = v + D.5627;
    D.5627 = rsize + nb;
    D.5629 = v + D.5627;
    D.5630 = D.5629->head;
    D.5631 = D.5630 | 1;
    D.5629->head = D.5631;
    goto <D.5632>;
    <D.5626>:
    D.5633 = nb | 3;
    v->head = D.5633;
    D.5634 = rsize | 1;
    r->head = D.5634;
    D.5635 = r + rsize;
    D.5635->prev_foot = rsize;
    D.5636 = rsize >> 3;
    if (D.5636 <= 31) goto <D.5637>; else goto <D.5638>;
    <D.5637>:
    {
      bindex_t I;
      struct malloc_chunk * B;
      struct malloc_chunk * F;

      I = rsize >> 3;
      D.5639 = I << 1;
      B = &m->smallbins[D.5639];
      F = B;
      D.5640 = m->smallmap;
      I.9 = (int) I;
      D.5642 = 1 << I.9;
      D.5643 = D.5640 & D.5642;
      if (D.5643 == 0) goto <D.5644>; else goto <D.5645>;
      <D.5644>:
      D.5640 = m->smallmap;
      I.9 = (int) I;
      D.5642 = 1 << I.9;
      D.5646 = D.5640 | D.5642;
      m->smallmap = D.5646;
      goto <D.5647>;
      <D.5645>:
      D.5648 = B->fd;
      D.5546 = m->least_addr;
      D.5649 = D.5648 >= D.5546;
      D.5650 = (long int) D.5649;
      D.5651 = __builtin_expect (D.5650, 1);
      if (D.5651 != 0) goto <D.5652>; else goto <D.5653>;
      <D.5652>:
      F = B->fd;
      goto <D.5654>;
      <D.5653>:
      abort ();
      <D.5654>:
      <D.5647>:
      B->fd = r;
      F->bk = r;
      r->fd = F;
      r->bk = B;
    }
    goto <D.5655>;
    <D.5638>:
    {
      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.5656>; else goto <D.5657>;
          <D.5656>:
          I = 0;
          goto <D.5658>;
          <D.5657>:
          if (X > 65535) goto <D.5659>; else goto <D.5660>;
          <D.5659>:
          I = 31;
          goto <D.5661>;
          <D.5660>:
          {
            unsigned int K;

            __asm__("bsrl %1,%0
	" : "=r" K : "rm" X);
            D.5662 = K << 1;
            D.5663 = K + 7;
            D.5664 = (int) D.5663;
            D.5665 = rsize >> D.5664;
            D.5666 = D.5665 & 1;
            I = D.5662 + D.5666;
          }
          <D.5661>:
          <D.5658>:
        }
        H = &m->treebins[I];
        TP->index = I;
        TP->child[1] = 0B;
        D.5667 = TP->child[1];
        TP->child[0] = D.5667;
        D.5529 = m->treemap;
        I.10 = (int) I;
        D.5669 = 1 << I.10;
        D.5670 = D.5529 & D.5669;
        if (D.5670 == 0) goto <D.5671>; else goto <D.5672>;
        <D.5671>:
        D.5529 = m->treemap;
        I.10 = (int) I;
        D.5669 = 1 << I.10;
        D.5673 = D.5529 | D.5669;
        m->treemap = D.5673;
        *H = TP;
        TP->parent = H;
        TP->bk = TP;
        D.5674 = TP->bk;
        TP->fd = D.5674;
        goto <D.5675>;
        <D.5672>:
        {
          struct malloc_tree_chunk * T;
          size_t K;

          T = *H;
          if (I != 31) goto <D.5677>; else goto <D.5678>;
          <D.5677>:
          D.5679 = I >> 1;
          D.5680 = 25 - D.5679;
          iftmp.11 = (int) D.5680;
          goto <D.5681>;
          <D.5678>:
          iftmp.11 = 0;
          <D.5681>:
          K = rsize << iftmp.11;
          <D.5071>:
          D.5682 = T->head;
          D.5683 = D.5682 & 4294967292;
          if (D.5683 != rsize) goto <D.5684>; else goto <D.5685>;
          <D.5684>:
          {
            struct malloc_tree_chunk * * C;

            D.5686 = K >> 31;
            C = &T->child[D.5686];
            K = K << 1;
            D.5687 = *C;
            if (D.5687 != 0B) goto <D.5688>; else goto <D.5689>;
            <D.5688>:
            T = *C;
            goto <D.5690>;
            <D.5689>:
            D.5546 = m->least_addr;
            D.5691 = D.5546 <= C;
            D.5692 = (long int) D.5691;
            D.5693 = __builtin_expect (D.5692, 1);
            if (D.5693 != 0) goto <D.5694>; else goto <D.5695>;
            <D.5694>:
            *C = TP;
            TP->parent = T;
            TP->bk = TP;
            D.5674 = TP->bk;
            TP->fd = D.5674;
            goto <D.5069>;
            <D.5695>:
            abort ();
            <D.5690>:
          }
          goto <D.5696>;
          <D.5685>:
          {
            struct malloc_tree_chunk * F;

            F = T->fd;
            D.5546 = m->least_addr;
            D.5698 = D.5546 <= T;
            D.5699 = (long int) D.5698;
            D.5700 = __builtin_expect (D.5699, 1);
            if (D.5700 != 0) goto <D.5701>; else goto <D.5697>;
            <D.5701>:
            D.5546 = m->least_addr;
            D.5702 = D.5546 <= F;
            D.5703 = (long int) D.5702;
            D.5704 = __builtin_expect (D.5703, 1);
            if (D.5704 != 0) goto <D.5705>; else goto <D.5697>;
            <D.5705>:
            F->bk = TP;
            D.5706 = F->bk;
            T->fd = D.5706;
            TP->fd = F;
            TP->bk = T;
            TP->parent = 0B;
            goto <D.5069>;
            <D.5697>:
            abort ();
          }
          <D.5696>:
          goto <D.5071>;
          <D.5069>:
        }
        <D.5675>:
      }
    }
    <D.5655>:
    <D.5632>:
    D.5707 = v + 8;
    return D.5707;
    <D.5556>:
  }
  <D.5551>:
  abort ();
  <D.5545>:
  <D.5541>:
  D.5707 = 0B;
  return D.5707;
}


sys_alloc (struct malloc_state * m, size_t nb)
{
  unsigned int D.5709;
  unsigned int D.5710;
  unsigned int D.5713;
  void * D.5718;
  struct malloc_segment * iftmp.12;
  struct malloc_chunk * D.5722;
  unsigned int D.5730;
  unsigned int D.5731;
  unsigned int D.5732;
  unsigned int D.5733;
  unsigned int D.5734;
  unsigned int D.5735;
  unsigned int base.13;
  unsigned int D.5737;
  unsigned int D.5740;
  unsigned int D.5741;
  unsigned int D.5742;
  unsigned int D.5743;
  unsigned int D.5749;
  unsigned int D.5750;
  unsigned int D.5751;
  unsigned int D.5752;
  char * D.5755;
  unsigned int D.5756;
  char * D.5757;
  unsigned int D.5766;
  unsigned int D.5769;
  unsigned int D.5770;
  unsigned int D.5771;
  unsigned int D.5780;
  unsigned int D.5783;
  _Bool D.5792;
  _Bool D.5793;
  _Bool D.5794;
  int end.14;
  int br.15;
  int D.5801;
  unsigned int D.5802;
  unsigned int D.5807;
  unsigned int D.5808;
  unsigned int D.5809;
  char * D.5814;
  unsigned int D.5815;
  unsigned int D.5818;
  struct malloc_chunk * D.5820;
  unsigned int D.5821;
  sizetype D.5822;
  sizetype D.5823;
  char * D.5824;
  int D.5825;
  int mn.16;
  int D.5827;
  unsigned int D.5828;
  unsigned int D.5829;
  char * D.5832;
  unsigned int D.5833;
  char * D.5834;
  unsigned int D.5838;
  unsigned int D.5839;
  unsigned int D.5841;
  unsigned int D.5845;
  unsigned int D.5846;
  unsigned int D.5856;
  struct malloc_chunk * D.5857;
  unsigned int D.5858;
  unsigned int D.5859;
  int * D.5860;
  char * tbase;
  size_t tsize;
  flag_t mmap_flag;

  tbase = 4294967295B;
  tsize = 0;
  mmap_flag = 0;
  init_mparams ();
  D.5709 = m->mflags;
  D.5710 = D.5709 & 1;
  if (D.5710 != 0) goto <D.5711>; else goto <D.5712>;
  <D.5711>:
  D.5713 = mparams.mmap_threshold;
  if (D.5713 <= nb) goto <D.5714>; else goto <D.5715>;
  <D.5714>:
  {
    void * mem;

    mem = mmap_alloc (m, nb);
    if (mem != 0B) goto <D.5716>; else goto <D.5717>;
    <D.5716>:
    D.5718 = mem;
    return D.5718;
    <D.5717>:
  }
  <D.5715>:
  <D.5712>:
  if (0 != 0) goto <D.5719>; else goto <D.5720>;
  <D.5719>:
  {
    char * br;
    struct malloc_segment * ss;
    size_t asize;

    br = 4294967295B;
    D.5722 = m->top;
    if (D.5722 != 0B) goto <D.5723>; else goto <D.5724>;
    <D.5723>:
    D.5722 = m->top;
    iftmp.12 = segment_holding (m, D.5722);
    goto <D.5725>;
    <D.5724>:
    iftmp.12 = 0B;
    <D.5725>:
    ss = iftmp.12;
    asize = 0;
    if (ss == 0B) goto <D.5726>; else goto <D.5727>;
    <D.5726>:
    {
      char * base;

      base = 4294967295B;
      if (base != 4294967295B) goto <D.5728>; else goto <D.5729>;
      <D.5728>:
      D.5730 = mparams.granularity;
      D.5731 = D.5730 + nb;
      D.5732 = D.5731 + 41;
      D.5730 = mparams.granularity;
      D.5733 = -D.5730;
      asize = D.5732 & D.5733;
      D.5734 = mparams.page_size;
      D.5735 = D.5734 + 4294967295;
      base.13 = (unsigned int) base;
      D.5737 = D.5735 & base.13;
      if (D.5737 != 0) goto <D.5738>; else goto <D.5739>;
      <D.5738>:
      D.5734 = mparams.page_size;
      base.13 = (unsigned int) base;
      D.5740 = D.5734 + base.13;
      D.5734 = mparams.page_size;
      D.5741 = -D.5734;
      D.5742 = D.5740 & D.5741;
      base.13 = (unsigned int) base;
      D.5743 = D.5742 - base.13;
      asize = D.5743 + asize;
      <D.5739>:
      if (asize <= 2147483646) goto <D.5744>; else goto <D.5745>;
      <D.5744>:
      br = 4294967295B;
      if (br == base) goto <D.5746>; else goto <D.5747>;
      <D.5746>:
      tbase = base;
      tsize = asize;
      <D.5747>:
      <D.5745>:
      <D.5729>:
    }
    goto <D.5748>;
    <D.5727>:
    D.5749 = m->topsize;
    D.5750 = nb - D.5749;
    D.5730 = mparams.granularity;
    D.5751 = D.5750 + D.5730;
    D.5752 = D.5751 + 41;
    D.5730 = mparams.granularity;
    D.5733 = -D.5730;
    asize = D.5752 & D.5733;
    if (asize <= 2147483646) goto <D.5753>; else goto <D.5754>;
    <D.5753>:
    br = 4294967295B;
    D.5755 = ss->base;
    D.5756 = ss->size;
    D.5757 = D.5755 + D.5756;
    if (br == D.5757) goto <D.5758>; else goto <D.5759>;
    <D.5758>:
    tbase = br;
    tsize = asize;
    <D.5759>:
    <D.5754>:
    <D.5748>:
    if (tbase == 4294967295B) goto <D.5760>; else goto <D.5761>;
    <D.5760>:
    if (br != 4294967295B) goto <D.5762>; else goto <D.5763>;
    <D.5762>:
    if (asize <= 2147483646) goto <D.5764>; else goto <D.5765>;
    <D.5764>:
    D.5766 = nb + 41;
    if (D.5766 > asize) goto <D.5767>; else goto <D.5768>;
    <D.5767>:
    {
      size_t esize;

      D.5769 = nb - asize;
      D.5730 = mparams.granularity;
      D.5770 = D.5769 + D.5730;
      D.5771 = D.5770 + 41;
      D.5730 = mparams.granularity;
      D.5733 = -D.5730;
      esize = D.5771 & D.5733;
      if (esize <= 2147483646) goto <D.5772>; else goto <D.5773>;
      <D.5772>:
      {
        char * end;

        end = 4294967295B;
        if (end != 4294967295B) goto <D.5774>; else goto <D.5775>;
        <D.5774>:
        asize = asize + esize;
        goto <D.5776>;
        <D.5775>:
        br = 4294967295B;
        <D.5776>:
      }
      <D.5773>:
    }
    <D.5768>:
    <D.5765>:
    <D.5763>:
    if (br != 4294967295B) goto <D.5777>; else goto <D.5778>;
    <D.5777>:
    tbase = br;
    tsize = asize;
    goto <D.5779>;
    <D.5778>:
    D.5709 = m->mflags;
    D.5780 = D.5709 | 4;
    m->mflags = D.5780;
    <D.5779>:
    <D.5761>:
  }
  <D.5720>:
  if (tbase == 4294967295B) goto <D.5781>; else goto <D.5782>;
  <D.5781>:
  {
    size_t req;
    size_t rsize;

    req = nb + 41;
    D.5730 = mparams.granularity;
    D.5783 = D.5730 + req;
    D.5730 = mparams.granularity;
    D.5733 = -D.5730;
    rsize = D.5783 & D.5733;
    if (rsize > nb) goto <D.5784>; else goto <D.5785>;
    <D.5784>:
    {
      char * mp;

      mp = mmap (0B, rsize, 7, 34, -1, 0);
      if (mp != 4294967295B) goto <D.5786>; else goto <D.5787>;
      <D.5786>:
      tbase = mp;
      tsize = rsize;
      mmap_flag = 1;
      <D.5787>:
    }
    <D.5785>:
  }
  <D.5782>:
  if (0 != 0) goto <D.5788>; else goto <D.5789>;
  <D.5788>:
  {
    size_t asize;

    D.5730 = mparams.granularity;
    D.5731 = D.5730 + nb;
    D.5732 = D.5731 + 41;
    D.5730 = mparams.granularity;
    D.5733 = -D.5730;
    asize = D.5732 & D.5733;
    if (asize <= 2147483646) goto <D.5790>; else goto <D.5791>;
    <D.5790>:
    {
      char * br;
      char * end;

      br = 4294967295B;
      end = 4294967295B;
      br = 4294967295B;
      end = 4294967295B;
      D.5792 = br != 4294967295B;
      D.5793 = end != 4294967295B;
      D.5794 = D.5792 & D.5793;
      if (D.5794 != 0) goto <D.5795>; else goto <D.5796>;
      <D.5795>:
      if (br < end) goto <D.5797>; else goto <D.5798>;
      <D.5797>:
      {
        size_t ssize;

        end.14 = (int) end;
        br.15 = (int) br;
        D.5801 = end.14 - br.15;
        ssize = (size_t) D.5801;
        D.5802 = nb + 40;
        if (D.5802 < ssize) goto <D.5803>; else goto <D.5804>;
        <D.5803>:
        tbase = br;
        tsize = ssize;
        <D.5804>:
      }
      <D.5798>:
      <D.5796>:
    }
    <D.5791>:
  }
  <D.5789>:
  if (tbase != 4294967295B) goto <D.5805>; else goto <D.5806>;
  <D.5805>:
  D.5807 = m->footprint;
  D.5808 = D.5807 + tsize;
  m->footprint = D.5808;
  D.5807 = m->footprint;
  D.5809 = m->max_footprint;
  if (D.5807 > D.5809) goto <D.5810>; else goto <D.5811>;
  <D.5810>:
  D.5807 = m->footprint;
  m->max_footprint = D.5807;
  <D.5811>:
  D.5722 = m->top;
  if (D.5722 == 0B) goto <D.5812>; else goto <D.5813>;
  <D.5812>:
  m->least_addr = tbase;
  D.5814 = m->least_addr;
  m->seg.base = D.5814;
  m->seg.size = tsize;
  m->seg.sflags = mmap_flag;
  D.5815 = mparams.magic;
  m->magic = D.5815;
  init_bins (m);
  if (m == &_gm_) goto <D.5816>; else goto <D.5817>;
  <D.5816>:
  D.5818 = tsize + 4294967256;
  init_top (m, tbase, D.5818);
  goto <D.5819>;
  <D.5817>:
  {
    struct malloc_chunk * mn;

    D.5820 = m + 4294967288;
    D.5821 = D.5820->head;
    D.5822 = D.5821 & 4294967292;
    D.5823 = D.5822 + 4294967288;
    mn = m + D.5823;
    D.5824 = tbase + tsize;
    D.5825 = (int) D.5824;
    mn.16 = (int) mn;
    D.5827 = D.5825 - mn.16;
    D.5828 = (unsigned int) D.5827;
    D.5829 = D.5828 + 4294967256;
    init_top (m, mn, D.5829);
  }
  <D.5819>:
  goto <D.5830>;
  <D.5813>:
  {
    struct malloc_segment * sp;

    sp = &m->seg;
    goto <D.4965>;
    <D.4964>:
    sp = sp->next;
    <D.4965>:
    if (sp != 0B) goto <D.5831>; else goto <D.4966>;
    <D.5831>:
    D.5832 = sp->base;
    D.5833 = sp->size;
    D.5834 = D.5832 + D.5833;
    if (D.5834 != tbase) goto <D.4964>; else goto <D.4966>;
    <D.4966>:
    if (sp != 0B) goto <D.5837>; else goto <D.5835>;
    <D.5837>:
    D.5838 = sp->sflags;
    D.5839 = D.5838 & 8;
    if (D.5839 == 0) goto <D.5840>; else goto <D.5835>;
    <D.5840>:
    D.5838 = sp->sflags;
    D.5841 = D.5838 & 1;
    if (D.5841 == mmap_flag) goto <D.5842>; else goto <D.5835>;
    <D.5842>:
    D.5722 = m->top;
    D.5832 = sp->base;
    if (D.5722 >= D.5832) goto <D.5843>; else goto <D.5835>;
    <D.5843>:
    D.5722 = m->top;
    D.5832 = sp->base;
    D.5833 = sp->size;
    D.5834 = D.5832 + D.5833;
    if (D.5722 < D.5834) goto <D.5844>; else goto <D.5835>;
    <D.5844>:
    D.5833 = sp->size;
    D.5845 = D.5833 + tsize;
    sp->size = D.5845;
    D.5749 = m->topsize;
    D.5846 = D.5749 + tsize;
    D.5722 = m->top;
    init_top (m, D.5722, D.5846);
    goto <D.5836>;
    <D.5835>:
    D.5814 = m->least_addr;
    if (D.5814 > tbase) goto <D.5847>; else goto <D.5848>;
    <D.5847>:
    m->least_addr = tbase;
    <D.5848>:
    sp = &m->seg;
    goto <D.4968>;
    <D.4967>:
    sp = sp->next;
    <D.4968>:
    if (sp != 0B) goto <D.5849>; else goto <D.4969>;
    <D.5849>:
    D.5832 = sp->base;
    D.5824 = tbase + tsize;
    if (D.5832 != D.5824) goto <D.4967>; else goto <D.4969>;
    <D.4969>:
    if (sp != 0B) goto <D.5851>; else goto <D.5850>;
    <D.5851>:
    D.5838 = sp->sflags;
    D.5839 = D.5838 & 8;
    if (D.5839 == 0) goto <D.5852>; else goto <D.5850>;
    <D.5852>:
    D.5838 = sp->sflags;
    D.5841 = D.5838 & 1;
    if (D.5841 == mmap_flag) goto <D.5853>; else goto <D.5850>;
    <D.5853>:
    {
      char * oldbase;

      oldbase = sp->base;
      sp->base = tbase;
      D.5833 = sp->size;
      D.5845 = D.5833 + tsize;
      sp->size = D.5845;
      D.5718 = prepend_alloc (m, tbase, oldbase, nb);
      return D.5718;
    }
    <D.5850>:
    add_segment (m, tbase, tsize, mmap_flag);
    <D.5836>:
  }
  <D.5830>:
  D.5749 = m->topsize;
  if (D.5749 > nb) goto <D.5854>; else goto <D.5855>;
  <D.5854>:
  {
    size_t rsize;
    struct malloc_chunk * p;
    struct malloc_chunk * r;

    D.5749 = m->topsize;
    D.5856 = D.5749 - nb;
    m->topsize = D.5856;
    rsize = m->topsize;
    p = m->top;
    D.5857 = p + nb;
    m->top = D.5857;
    r = m->top;
    D.5858 = rsize | 1;
    r->head = D.5858;
    D.5859 = nb | 3;
    p->head = D.5859;
    D.5718 = p + 8;
    return D.5718;
  }
  <D.5855>:
  <D.5806>:
  D.5860 = __errno_location ();
  *D.5860 = 12;
  D.5718 = 0B;
  return D.5718;
}


mmap_alloc (struct malloc_state * m, size_t nb)
{
  unsigned int D.5862;
  unsigned int D.5863;
  unsigned int D.5864;
  unsigned int D.5865;
  unsigned int iftmp.17;
  void * D.5871;
  unsigned int D.5872;
  unsigned int D.5873;
  unsigned int D.5876;
  unsigned int D.5878;
  unsigned int D.5879;
  unsigned int D.5880;
  struct malloc_chunk * D.5881;
  sizetype D.5882;
  struct malloc_chunk * D.5883;
  char * D.5884;
  unsigned int D.5887;
  unsigned int D.5888;
  unsigned int D.5889;
  void * D.5892;
  size_t mmsize;

  D.5862 = mparams.granularity;
  D.5863 = D.5862 + nb;
  D.5864 = D.5863 + 31;
  D.5862 = mparams.granularity;
  D.5865 = -D.5862;
  mmsize = D.5864 & D.5865;
  if (mmsize > nb) goto <D.5866>; else goto <D.5867>;
  <D.5866>:
  {
    char * mm;

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

      D.5871 = mm + 8;
      D.5872 = (unsigned int) D.5871;
      D.5873 = D.5872 & 7;
      if (D.5873 != 0) goto <D.5874>; else goto <D.5875>;
      <D.5874>:
      D.5871 = mm + 8;
      D.5872 = (unsigned int) D.5871;
      D.5876 = -D.5872;
      iftmp.17 = D.5876 & 7;
      goto <D.5877>;
      <D.5875>:
      iftmp.17 = 0;
      <D.5877>:
      offset = iftmp.17;
      D.5878 = mmsize - offset;
      psize = D.5878 + 4294967280;
      p = mm + offset;
      D.5879 = offset | 1;
      p->prev_foot = D.5879;
      D.5880 = psize | 2;
      p->head = D.5880;
      D.5881 = p + psize;
      D.5881->head = 7;
      D.5882 = psize + 4;
      D.5883 = p + D.5882;
      D.5883->head = 0;
      D.5884 = m->least_addr;
      if (D.5884 > mm) goto <D.5885>; else goto <D.5886>;
      <D.5885>:
      m->least_addr = mm;
      <D.5886>:
      D.5887 = m->footprint;
      D.5888 = D.5887 + mmsize;
      m->footprint = D.5888;
      D.5887 = m->footprint;
      D.5889 = m->max_footprint;
      if (D.5887 > D.5889) goto <D.5890>; else goto <D.5891>;
      <D.5890>:
      D.5887 = m->footprint;
      m->max_footprint = D.5887;
      <D.5891>:
      D.5892 = p + 8;
      return D.5892;
    }
    <D.5869>:
  }
  <D.5867>:
  D.5892 = 0B;
  return D.5892;
}


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

  i = 0;
  goto <D.4857>;
  <D.4856>:
  {
    struct malloc_chunk * bin;

    D.5894 = i << 1;
    bin = &m->smallbins[D.5894];
    bin->bk = bin;
    D.5895 = bin->bk;
    bin->fd = D.5895;
  }
  i = i + 1;
  <D.4857>:
  if (i <= 31) goto <D.4856>; else goto <D.4858>;
  <D.4858>:
}


init_top (struct malloc_state * m, struct malloc_chunk * p, size_t psize)
{
  unsigned int iftmp.18;
  void * D.5897;
  unsigned int D.5898;
  unsigned int D.5899;
  unsigned int D.5902;
  unsigned int D.5904;
  struct malloc_chunk * D.5905;
  unsigned int D.5906;
  size_t offset;

  D.5897 = p + 8;
  D.5898 = (unsigned int) D.5897;
  D.5899 = D.5898 & 7;
  if (D.5899 != 0) goto <D.5900>; else goto <D.5901>;
  <D.5900>:
  D.5897 = p + 8;
  D.5898 = (unsigned int) D.5897;
  D.5902 = -D.5898;
  iftmp.18 = D.5902 & 7;
  goto <D.5903>;
  <D.5901>:
  iftmp.18 = 0;
  <D.5903>:
  offset = iftmp.18;
  p = p + offset;
  psize = psize - offset;
  m->top = p;
  m->topsize = psize;
  D.5904 = psize | 1;
  p->head = D.5904;
  D.5905 = p + psize;
  D.5905->head = 40;
  D.5906 = mparams.trim_threshold;
  m->trim_check = D.5906;
}


prepend_alloc (struct malloc_state * m, char * newbase, char * oldbase, size_t nb)
{
  sizetype iftmp.19;
  void * D.5908;
  unsigned int D.5909;
  unsigned int D.5910;
  unsigned int D.5913;
  sizetype iftmp.20;
  void * D.5916;
  unsigned int D.5917;
  unsigned int D.5918;
  unsigned int D.5921;
  int oldfirst.21;
  int p.22;
  int D.5925;
  unsigned int D.5926;
  struct malloc_chunk * D.5927;
  unsigned int D.5930;
  unsigned int D.5931;
  unsigned int D.5932;
  struct malloc_chunk * D.5934;
  unsigned int D.5937;
  unsigned int D.5938;
  unsigned int D.5939;
  struct malloc_chunk * D.5940;
  unsigned int D.5942;
  unsigned int D.5943;
  unsigned int D.5946;
  unsigned int D.5951;
  int I.23;
  unsigned int D.5953;
  unsigned int D.5954;
  unsigned int D.5955;
  int iftmp.24;
  unsigned int D.5963;
  struct malloc_chunk * * D.5964;
  _Bool D.5965;
  long int D.5966;
  long int D.5967;
  char * D.5969;
  _Bool D.5970;
  long int D.5971;
  long int D.5972;
  int iftmp.25;
  _Bool D.5978;
  long int D.5979;
  long int D.5980;
  _Bool D.5982;
  long int D.5983;
  long int D.5984;
  struct malloc_tree_chunk * D.5987;
  _Bool D.5990;
  long int D.5991;
  long int D.5992;
  struct malloc_tree_chunk * D.6000;
  _Bool D.6002;
  long int D.6003;
  long int D.6004;
  unsigned int D.6010;
  struct malloc_tree_chunk * D.6011;
  unsigned int D.6016;
  int D.6017;
  unsigned int D.6018;
  unsigned int D.6019;
  unsigned int D.6020;
  _Bool D.6022;
  long int D.6023;
  long int D.6024;
  struct malloc_tree_chunk * D.6027;
  _Bool D.6034;
  long int D.6035;
  long int D.6036;
  _Bool D.6041;
  long int D.6042;
  long int D.6043;
  _Bool D.6049;
  long int D.6050;
  long int D.6051;
  unsigned int D.6056;
  unsigned int D.6057;
  struct malloc_chunk * D.6058;
  unsigned int D.6059;
  unsigned int D.6062;
  int I.26;
  unsigned int D.6064;
  unsigned int D.6065;
  unsigned int D.6068;
  struct malloc_chunk * D.6070;
  _Bool D.6071;
  long int D.6072;
  long int D.6073;
  unsigned int D.6084;
  unsigned int D.6085;
  int D.6086;
  unsigned int D.6087;
  unsigned int D.6088;
  struct malloc_tree_chunk * D.6089;
  int I.27;
  unsigned int D.6091;
  unsigned int D.6092;
  unsigned int D.6095;
  struct malloc_tree_chunk * D.6096;
  int iftmp.28;
  unsigned int D.6101;
  unsigned int D.6102;
  unsigned int D.6104;
  unsigned int D.6105;
  unsigned int D.6108;
  struct malloc_tree_chunk * D.6109;
  _Bool D.6113;
  long int D.6114;
  long int D.6115;
  _Bool D.6120;
  long int D.6121;
  long int D.6122;
  _Bool D.6124;
  long int D.6125;
  long int D.6126;
  struct malloc_tree_chunk * D.6128;
  void * D.6129;
  struct malloc_chunk * p;
  struct malloc_chunk * oldfirst;
  size_t psize;
  struct malloc_chunk * q;
  size_t qsize;

  D.5908 = newbase + 8;
  D.5909 = (unsigned int) D.5908;
  D.5910 = D.5909 & 7;
  if (D.5910 != 0) goto <D.5911>; else goto <D.5912>;
  <D.5911>:
  D.5908 = newbase + 8;
  D.5909 = (unsigned int) D.5908;
  D.5913 = -D.5909;
  iftmp.19 = D.5913 & 7;
  goto <D.5914>;
  <D.5912>:
  iftmp.19 = 0;
  <D.5914>:
  p = newbase + iftmp.19;
  D.5916 = oldbase + 8;
  D.5917 = (unsigned int) D.5916;
  D.5918 = D.5917 & 7;
  if (D.5918 != 0) goto <D.5919>; else goto <D.5920>;
  <D.5919>:
  D.5916 = oldbase + 8;
  D.5917 = (unsigned int) D.5916;
  D.5921 = -D.5917;
  iftmp.20 = D.5921 & 7;
  goto <D.5922>;
  <D.5920>:
  iftmp.20 = 0;
  <D.5922>:
  oldfirst = oldbase + iftmp.20;
  oldfirst.21 = (int) oldfirst;
  p.22 = (int) p;
  D.5925 = oldfirst.21 - p.22;
  psize = (size_t) D.5925;
  q = p + nb;
  qsize = psize - nb;
  D.5926 = nb | 3;
  p->head = D.5926;
  D.5927 = m->top;
  if (D.5927 == oldfirst) goto <D.5928>; else goto <D.5929>;
  <D.5928>:
  {
    size_t tsize;

    D.5930 = m->topsize;
    D.5931 = D.5930 + qsize;
    m->topsize = D.5931;
    tsize = m->topsize;
    m->top = q;
    D.5932 = tsize | 1;
    q->head = D.5932;
  }
  goto <D.5933>;
  <D.5929>:
  D.5934 = m->dv;
  if (D.5934 == oldfirst) goto <D.5935>; else goto <D.5936>;
  <D.5935>:
  {
    size_t dsize;

    D.5937 = m->dvsize;
    D.5938 = D.5937 + qsize;
    m->dvsize = D.5938;
    dsize = m->dvsize;
    m->dv = q;
    D.5939 = dsize | 1;
    q->head = D.5939;
    D.5940 = q + dsize;
    D.5940->prev_foot = dsize;
  }
  goto <D.5941>;
  <D.5936>:
  D.5942 = oldfirst->head;
  D.5943 = D.5942 & 2;
  if (D.5943 == 0) goto <D.5944>; else goto <D.5945>;
  <D.5944>:
  {
    size_t nsize;

    D.5942 = oldfirst->head;
    nsize = D.5942 & 4294967292;
    D.5946 = nsize >> 3;
    if (D.5946 <= 31) goto <D.5947>; else goto <D.5948>;
    <D.5947>:
    {
      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.5949>; else goto <D.5950>;
      <D.5949>:
      D.5951 = m->smallmap;
      I.23 = (int) I;
      D.5953 = 1 << I.23;
      D.5954 = ~D.5953;
      D.5955 = D.5951 & D.5954;
      m->smallmap = D.5955;
      goto <D.5956>;
      <D.5950>:
      D.5963 = I << 1;
      D.5964 = &m->smallbins[D.5963];
      D.5965 = D.5964 == F;
      D.5966 = (long int) D.5965;
      D.5967 = __builtin_expect (D.5966, 1);
      if (D.5967 != 0) goto <D.5960>; else goto <D.5968>;
      <D.5968>:
      D.5969 = m->least_addr;
      D.5970 = D.5969 <= F;
      D.5971 = (long int) D.5970;
      D.5972 = __builtin_expect (D.5971, 1);
      if (D.5972 != 0) goto <D.5960>; else goto <D.5961>;
      <D.5960>:
      iftmp.24 = 1;
      goto <D.5962>;
      <D.5961>:
      iftmp.24 = 0;
      <D.5962>:
      if (iftmp.24 != 0) goto <D.5973>; else goto <D.5957>;
      <D.5973>:
      D.5963 = I << 1;
      D.5964 = &m->smallbins[D.5963];
      D.5978 = D.5964 == B;
      D.5979 = (long int) D.5978;
      D.5980 = __builtin_expect (D.5979, 1);
      if (D.5980 != 0) goto <D.5975>; else goto <D.5981>;
      <D.5981>:
      D.5969 = m->least_addr;
      D.5982 = D.5969 <= B;
      D.5983 = (long int) D.5982;
      D.5984 = __builtin_expect (D.5983, 1);
      if (D.5984 != 0) goto <D.5975>; else goto <D.5976>;
      <D.5975>:
      iftmp.25 = 1;
      goto <D.5977>;
      <D.5976>:
      iftmp.25 = 0;
      <D.5977>:
      if (iftmp.25 != 0) goto <D.5985>; else goto <D.5957>;
      <D.5985>:
      F->bk = B;
      B->fd = F;
      goto <D.5958>;
      <D.5957>:
      abort ();
      <D.5958>:
      <D.5956>:
    }
    goto <D.5986>;
    <D.5948>:
    {
      struct malloc_tree_chunk * TP;

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

        XP = TP->parent;
        D.5987 = TP->bk;
        if (D.5987 != TP) goto <D.5988>; else goto <D.5989>;
        <D.5988>:
        {
          struct malloc_tree_chunk * F;

          F = TP->fd;
          R = TP->bk;
          D.5969 = m->least_addr;
          D.5990 = D.5969 <= F;
          D.5991 = (long int) D.5990;
          D.5992 = __builtin_expect (D.5991, 1);
          if (D.5992 != 0) goto <D.5993>; else goto <D.5994>;
          <D.5993>:
          F->bk = R;
          R->fd = F;
          goto <D.5995>;
          <D.5994>:
          abort ();
          <D.5995>:
        }
        goto <D.5996>;
        <D.5989>:
        {
          struct malloc_tree_chunk * * RP;

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

            goto <D.4883>;
            <D.4882>:
            RP = CP;
            R = *RP;
            <D.4883>:
            CP = &R->child[1];
            D.6000 = *CP;
            if (D.6000 != 0B) goto <D.4882>; else goto <D.6001>;
            <D.6001>:
            CP = &R->child[0];
            D.6000 = *CP;
            if (D.6000 != 0B) goto <D.4882>; else goto <D.4884>;
            <D.4884>:
            D.5969 = m->least_addr;
            D.6002 = D.5969 <= RP;
            D.6003 = (long int) D.6002;
            D.6004 = __builtin_expect (D.6003, 1);
            if (D.6004 != 0) goto <D.6005>; else goto <D.6006>;
            <D.6005>:
            *RP = 0B;
            goto <D.6007>;
            <D.6006>:
            abort ();
            <D.6007>:
          }
          <D.5998>:
        }
        <D.5996>:
        if (XP != 0B) goto <D.6008>; else goto <D.6009>;
        <D.6008>:
        {
          struct malloc_tree_chunk * * H;

          D.6010 = TP->index;
          H = &m->treebins[D.6010];
          D.6011 = *H;
          if (D.6011 == TP) goto <D.6012>; else goto <D.6013>;
          <D.6012>:
          *H = R;
          D.6011 = *H;
          if (D.6011 == 0B) goto <D.6014>; else goto <D.6015>;
          <D.6014>:
          D.6016 = m->treemap;
          D.6010 = TP->index;
          D.6017 = (int) D.6010;
          D.6018 = 1 << D.6017;
          D.6019 = ~D.6018;
          D.6020 = D.6016 & D.6019;
          m->treemap = D.6020;
          <D.6015>:
          goto <D.6021>;
          <D.6013>:
          D.5969 = m->least_addr;
          D.6022 = D.5969 <= XP;
          D.6023 = (long int) D.6022;
          D.6024 = __builtin_expect (D.6023, 1);
          if (D.6024 != 0) goto <D.6025>; else goto <D.6026>;
          <D.6025>:
          D.6027 = XP->child[0];
          if (D.6027 == TP) goto <D.6028>; else goto <D.6029>;
          <D.6028>:
          XP->child[0] = R;
          goto <D.6030>;
          <D.6029>:
          XP->child[1] = R;
          <D.6030>:
          goto <D.6031>;
          <D.6026>:
          abort ();
          <D.6031>:
          <D.6021>:
          if (R != 0B) goto <D.6032>; else goto <D.6033>;
          <D.6032>:
          D.5969 = m->least_addr;
          D.6034 = D.5969 <= R;
          D.6035 = (long int) D.6034;
          D.6036 = __builtin_expect (D.6035, 1);
          if (D.6036 != 0) goto <D.6037>; else goto <D.6038>;
          <D.6037>:
          {
            struct malloc_tree_chunk * C0;
            struct malloc_tree_chunk * C1;

            R->parent = XP;
            C0 = TP->child[0];
            if (C0 != 0B) goto <D.6039>; else goto <D.6040>;
            <D.6039>:
            D.5969 = m->least_addr;
            D.6041 = D.5969 <= C0;
            D.6042 = (long int) D.6041;
            D.6043 = __builtin_expect (D.6042, 1);
            if (D.6043 != 0) goto <D.6044>; else goto <D.6045>;
            <D.6044>:
            R->child[0] = C0;
            C0->parent = R;
            goto <D.6046>;
            <D.6045>:
            abort ();
            <D.6046>:
            <D.6040>:
            C1 = TP->child[1];
            if (C1 != 0B) goto <D.6047>; else goto <D.6048>;
            <D.6047>:
            D.5969 = m->least_addr;
            D.6049 = D.5969 <= C1;
            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>:
            R->child[1] = C1;
            C1->parent = R;
            goto <D.6054>;
            <D.6053>:
            abort ();
            <D.6054>:
            <D.6048>:
          }
          goto <D.6055>;
          <D.6038>:
          abort ();
          <D.6055>:
          <D.6033>:
        }
        <D.6009>:
      }
    }
    <D.5986>:
    oldfirst = oldfirst + nsize;
    qsize = qsize + nsize;
  }
  <D.5945>:
  D.5942 = oldfirst->head;
  D.6056 = D.5942 & 4294967294;
  oldfirst->head = D.6056;
  D.6057 = qsize | 1;
  q->head = D.6057;
  D.6058 = q + qsize;
  D.6058->prev_foot = qsize;
  D.6059 = qsize >> 3;
  if (D.6059 <= 31) goto <D.6060>; else goto <D.6061>;
  <D.6060>:
  {
    bindex_t I;
    struct malloc_chunk * B;
    struct malloc_chunk * F;

    I = qsize >> 3;
    D.6062 = I << 1;
    B = &m->smallbins[D.6062];
    F = B;
    D.5951 = m->smallmap;
    I.26 = (int) I;
    D.6064 = 1 << I.26;
    D.6065 = D.5951 & D.6064;
    if (D.6065 == 0) goto <D.6066>; else goto <D.6067>;
    <D.6066>:
    D.5951 = m->smallmap;
    I.26 = (int) I;
    D.6064 = 1 << I.26;
    D.6068 = D.5951 | D.6064;
    m->smallmap = D.6068;
    goto <D.6069>;
    <D.6067>:
    D.6070 = B->fd;
    D.5969 = m->least_addr;
    D.6071 = D.6070 >= D.5969;
    D.6072 = (long int) D.6071;
    D.6073 = __builtin_expect (D.6072, 1);
    if (D.6073 != 0) goto <D.6074>; else goto <D.6075>;
    <D.6074>:
    F = B->fd;
    goto <D.6076>;
    <D.6075>:
    abort ();
    <D.6076>:
    <D.6069>:
    B->fd = q;
    F->bk = q;
    q->fd = F;
    q->bk = B;
  }
  goto <D.6077>;
  <D.6061>:
  {
    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.6078>; else goto <D.6079>;
        <D.6078>:
        I = 0;
        goto <D.6080>;
        <D.6079>:
        if (X > 65535) goto <D.6081>; else goto <D.6082>;
        <D.6081>:
        I = 31;
        goto <D.6083>;
        <D.6082>:
        {
          unsigned int K;

          __asm__("bsrl %1,%0
	" : "=r" K : "rm" X);
          D.6084 = K << 1;
          D.6085 = K + 7;
          D.6086 = (int) D.6085;
          D.6087 = qsize >> D.6086;
          D.6088 = D.6087 & 1;
          I = D.6084 + D.6088;
        }
        <D.6083>:
        <D.6080>:
      }
      H = &m->treebins[I];
      TP->index = I;
      TP->child[1] = 0B;
      D.6089 = TP->child[1];
      TP->child[0] = D.6089;
      D.6016 = m->treemap;
      I.27 = (int) I;
      D.6091 = 1 << I.27;
      D.6092 = D.6016 & D.6091;
      if (D.6092 == 0) goto <D.6093>; else goto <D.6094>;
      <D.6093>:
      D.6016 = m->treemap;
      I.27 = (int) I;
      D.6091 = 1 << I.27;
      D.6095 = D.6016 | D.6091;
      m->treemap = D.6095;
      *H = TP;
      TP->parent = H;
      TP->bk = TP;
      D.6096 = TP->bk;
      TP->fd = D.6096;
      goto <D.6097>;
      <D.6094>:
      {
        struct malloc_tree_chunk * T;
        size_t K;

        T = *H;
        if (I != 31) goto <D.6099>; else goto <D.6100>;
        <D.6099>:
        D.6101 = I >> 1;
        D.6102 = 25 - D.6101;
        iftmp.28 = (int) D.6102;
        goto <D.6103>;
        <D.6100>:
        iftmp.28 = 0;
        <D.6103>:
        K = qsize << iftmp.28;
        <D.4901>:
        D.6104 = T->head;
        D.6105 = D.6104 & 4294967292;
        if (D.6105 != qsize) goto <D.6106>; else goto <D.6107>;
        <D.6106>:
        {
          struct malloc_tree_chunk * * C;

          D.6108 = K >> 31;
          C = &T->child[D.6108];
          K = K << 1;
          D.6109 = *C;
          if (D.6109 != 0B) goto <D.6110>; else goto <D.6111>;
          <D.6110>:
          T = *C;
          goto <D.6112>;
          <D.6111>:
          D.5969 = m->least_addr;
          D.6113 = D.5969 <= C;
          D.6114 = (long int) D.6113;
          D.6115 = __builtin_expect (D.6114, 1);
          if (D.6115 != 0) goto <D.6116>; else goto <D.6117>;
          <D.6116>:
          *C = TP;
          TP->parent = T;
          TP->bk = TP;
          D.6096 = TP->bk;
          TP->fd = D.6096;
          goto <D.4899>;
          <D.6117>:
          abort ();
          <D.6112>:
        }
        goto <D.6118>;
        <D.6107>:
        {
          struct malloc_tree_chunk * F;

          F = T->fd;
          D.5969 = m->least_addr;
          D.6120 = D.5969 <= T;
          D.6121 = (long int) D.6120;
          D.6122 = __builtin_expect (D.6121, 1);
          if (D.6122 != 0) goto <D.6123>; else goto <D.6119>;
          <D.6123>:
          D.5969 = m->least_addr;
          D.6124 = D.5969 <= F;
          D.6125 = (long int) D.6124;
          D.6126 = __builtin_expect (D.6125, 1);
          if (D.6126 != 0) goto <D.6127>; else goto <D.6119>;
          <D.6127>:
          F->bk = TP;
          D.6128 = F->bk;
          T->fd = D.6128;
          TP->fd = F;
          TP->bk = T;
          TP->parent = 0B;
          goto <D.4899>;
          <D.6119>:
          abort ();
        }
        <D.6118>:
        goto <D.4901>;
        <D.4899>:
      }
      <D.6097>:
    }
  }
  <D.6077>:
  <D.5941>:
  <D.5933>:
  D.6129 = p + 8;
  return D.6129;
}


add_segment (struct malloc_state * m, char * tbase, size_t tsize, flag_t mmapped)
{
  char * D.6131;
  unsigned int D.6132;
  sizetype D.6133;
  unsigned int iftmp.29;
  void * D.6135;
  unsigned int D.6136;
  unsigned int D.6137;
  unsigned int D.6140;
  char * iftmp.30;
  char * D.6143;
  unsigned int D.6147;
  unsigned int D.6148;
  size_t * D.6149;
  int csp.31;
  int old_top.32;
  int D.6155;
  unsigned int D.6156;
  unsigned int D.6157;
  unsigned int D.6158;
  struct malloc_chunk * D.6159;
  unsigned int D.6160;
  unsigned int D.6163;
  unsigned int D.6164;
  int I.33;
  unsigned int D.6166;
  unsigned int D.6167;
  unsigned int D.6170;
  struct malloc_chunk * D.6172;
  char * D.6173;
  _Bool D.6174;
  long int D.6175;
  long int D.6176;
  unsigned int D.6187;
  unsigned int D.6188;
  int D.6189;
  unsigned int D.6190;
  unsigned int D.6191;
  struct malloc_tree_chunk * D.6192;
  unsigned int D.6193;
  int I.34;
  unsigned int D.6195;
  unsigned int D.6196;
  unsigned int D.6199;
  struct malloc_tree_chunk * D.6200;
  int iftmp.35;
  unsigned int D.6205;
  unsigned int D.6206;
  unsigned int D.6208;
  unsigned int D.6209;
  unsigned int D.6212;
  struct malloc_tree_chunk * D.6213;
  _Bool D.6217;
  long int D.6218;
  long int D.6219;
  _Bool D.6224;
  long int D.6225;
  long int D.6226;
  _Bool D.6228;
  long int D.6229;
  long int D.6230;
  struct malloc_tree_chunk * D.6232;
  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.6131 = oldsp->base;
  D.6132 = oldsp->size;
  old_end = D.6131 + D.6132;
  ssize = 24;
  D.6133 = 4294967273 - ssize;
  rawsp = old_end + D.6133;
  D.6135 = rawsp + 8;
  D.6136 = (unsigned int) D.6135;
  D.6137 = D.6136 & 7;
  if (D.6137 != 0) goto <D.6138>; else goto <D.6139>;
  <D.6138>:
  D.6135 = rawsp + 8;
  D.6136 = (unsigned int) D.6135;
  D.6140 = -D.6136;
  iftmp.29 = D.6140 & 7;
  goto <D.6141>;
  <D.6139>:
  iftmp.29 = 0;
  <D.6141>:
  offset = iftmp.29;
  asp = rawsp + offset;
  D.6143 = old_top + 16;
  if (D.6143 > asp) goto <D.6144>; else goto <D.6145>;
  <D.6144>:
  iftmp.30 = old_top;
  goto <D.6146>;
  <D.6145>:
  iftmp.30 = asp;
  <D.6146>:
  csp = iftmp.30;
  sp = csp;
  ss = sp + 8;
  tnext = sp + ssize;
  p = tnext;
  nfences = 0;
  D.6147 = tsize + 4294967256;
  init_top (m, tbase, D.6147);
  D.6148 = ssize | 3;
  sp->head = D.6148;
  *ss = m->seg;
  m->seg.base = tbase;
  m->seg.size = tsize;
  m->seg.sflags = mmapped;
  m->seg.next = ss;
  <D.4923>:
  {
    struct malloc_chunk * nextp;

    nextp = p + 4;
    p->head = 7;
    nfences = nfences + 1;
    D.6149 = &nextp->head;
    if (D.6149 < old_end) goto <D.6150>; else goto <D.4922>;
    <D.6150>:
    p = nextp;
  }
  goto <D.4923>;
  <D.4922>:
  if (csp != old_top) goto <D.6151>; else goto <D.6152>;
  <D.6151>:
  {
    struct malloc_chunk * q;
    size_t psize;
    struct malloc_chunk * tn;

    q = old_top;
    csp.31 = (int) csp;
    old_top.32 = (int) old_top;
    D.6155 = csp.31 - old_top.32;
    psize = (size_t) D.6155;
    tn = q + psize;
    D.6156 = tn->head;
    D.6157 = D.6156 & 4294967294;
    tn->head = D.6157;
    D.6158 = psize | 1;
    q->head = D.6158;
    D.6159 = q + psize;
    D.6159->prev_foot = psize;
    D.6160 = psize >> 3;
    if (D.6160 <= 31) goto <D.6161>; else goto <D.6162>;
    <D.6161>:
    {
      bindex_t I;
      struct malloc_chunk * B;
      struct malloc_chunk * F;

      I = psize >> 3;
      D.6163 = I << 1;
      B = &m->smallbins[D.6163];
      F = B;
      D.6164 = m->smallmap;
      I.33 = (int) I;
      D.6166 = 1 << I.33;
      D.6167 = D.6164 & D.6166;
      if (D.6167 == 0) goto <D.6168>; else goto <D.6169>;
      <D.6168>:
      D.6164 = m->smallmap;
      I.33 = (int) I;
      D.6166 = 1 << I.33;
      D.6170 = D.6164 | D.6166;
      m->smallmap = D.6170;
      goto <D.6171>;
      <D.6169>:
      D.6172 = B->fd;
      D.6173 = m->least_addr;
      D.6174 = D.6172 >= D.6173;
      D.6175 = (long int) D.6174;
      D.6176 = __builtin_expect (D.6175, 1);
      if (D.6176 != 0) goto <D.6177>; else goto <D.6178>;
      <D.6177>:
      F = B->fd;
      goto <D.6179>;
      <D.6178>:
      abort ();
      <D.6179>:
      <D.6171>:
      B->fd = q;
      F->bk = q;
      q->fd = F;
      q->bk = B;
    }
    goto <D.6180>;
    <D.6162>:
    {
      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.6181>; else goto <D.6182>;
          <D.6181>:
          I = 0;
          goto <D.6183>;
          <D.6182>:
          if (X > 65535) goto <D.6184>; else goto <D.6185>;
          <D.6184>:
          I = 31;
          goto <D.6186>;
          <D.6185>:
          {
            unsigned int K;

            __asm__("bsrl %1,%0
	" : "=r" K : "rm" X);
            D.6187 = K << 1;
            D.6188 = K + 7;
            D.6189 = (int) D.6188;
            D.6190 = psize >> D.6189;
            D.6191 = D.6190 & 1;
            I = D.6187 + D.6191;
          }
          <D.6186>:
          <D.6183>:
        }
        H = &m->treebins[I];
        TP->index = I;
        TP->child[1] = 0B;
        D.6192 = TP->child[1];
        TP->child[0] = D.6192;
        D.6193 = m->treemap;
        I.34 = (int) I;
        D.6195 = 1 << I.34;
        D.6196 = D.6193 & D.6195;
        if (D.6196 == 0) goto <D.6197>; else goto <D.6198>;
        <D.6197>:
        D.6193 = m->treemap;
        I.34 = (int) I;
        D.6195 = 1 << I.34;
        D.6199 = D.6193 | D.6195;
        m->treemap = D.6199;
        *H = TP;
        TP->parent = H;
        TP->bk = TP;
        D.6200 = TP->bk;
        TP->fd = D.6200;
        goto <D.6201>;
        <D.6198>:
        {
          struct malloc_tree_chunk * T;
          size_t K;

          T = *H;
          if (I != 31) goto <D.6203>; else goto <D.6204>;
          <D.6203>:
          D.6205 = I >> 1;
          D.6206 = 25 - D.6205;
          iftmp.35 = (int) D.6206;
          goto <D.6207>;
          <D.6204>:
          iftmp.35 = 0;
          <D.6207>:
          K = psize << iftmp.35;
          <D.4940>:
          D.6208 = T->head;
          D.6209 = D.6208 & 4294967292;
          if (D.6209 != psize) goto <D.6210>; else goto <D.6211>;
          <D.6210>:
          {
            struct malloc_tree_chunk * * C;

            D.6212 = K >> 31;
            C = &T->child[D.6212];
            K = K << 1;
            D.6213 = *C;
            if (D.6213 != 0B) goto <D.6214>; else goto <D.6215>;
            <D.6214>:
            T = *C;
            goto <D.6216>;
            <D.6215>:
            D.6173 = m->least_addr;
            D.6217 = D.6173 <= C;
            D.6218 = (long int) D.6217;
            D.6219 = __builtin_expect (D.6218, 1);
            if (D.6219 != 0) goto <D.6220>; else goto <D.6221>;
            <D.6220>:
            *C = TP;
            TP->parent = T;
            TP->bk = TP;
            D.6200 = TP->bk;
            TP->fd = D.6200;
            goto <D.4938>;
            <D.6221>:
            abort ();
            <D.6216>:
          }
          goto <D.6222>;
          <D.6211>:
          {
            struct malloc_tree_chunk * F;

            F = T->fd;
            D.6173 = m->least_addr;
            D.6224 = D.6173 <= T;
            D.6225 = (long int) D.6224;
            D.6226 = __builtin_expect (D.6225, 1);
            if (D.6226 != 0) goto <D.6227>; else goto <D.6223>;
            <D.6227>:
            D.6173 = m->least_addr;
            D.6228 = D.6173 <= F;
            D.6229 = (long int) D.6228;
            D.6230 = __builtin_expect (D.6229, 1);
            if (D.6230 != 0) goto <D.6231>; else goto <D.6223>;
            <D.6231>:
            F->bk = TP;
            D.6232 = F->bk;
            T->fd = D.6232;
            TP->fd = F;
            TP->bk = T;
            TP->parent = 0B;
            goto <D.4938>;
            <D.6223>:
            abort ();
          }
          <D.6222>:
          goto <D.4940>;
          <D.4938>:
        }
        <D.6201>:
      }
    }
    <D.6180>:
  }
  <D.6152>:
}


segment_holding (struct malloc_state * m, char * addr)
{
  char * D.6233;
  unsigned int D.6236;
  char * D.6237;
  struct malloc_segment * D.6240;
  struct malloc_segment * sp;

  sp = &m->seg;
  <D.4825>:
  D.6233 = sp->base;
  if (D.6233 <= addr) goto <D.6234>; else goto <D.6235>;
  <D.6234>:
  D.6233 = sp->base;
  D.6236 = sp->size;
  D.6237 = D.6233 + D.6236;
  if (D.6237 > addr) goto <D.6238>; else goto <D.6239>;
  <D.6238>:
  D.6240 = sp;
  return D.6240;
  <D.6239>:
  <D.6235>:
  sp = sp->next;
  if (sp == 0B) goto <D.6241>; else goto <D.6242>;
  <D.6241>:
  D.6240 = 0B;
  return D.6240;
  <D.6242>:
  goto <D.4825>;
}


dlfree (void * mem)
{
  unsigned int D.6250;
  int D.6252;
  unsigned int D.6253;
  unsigned int D.6254;
  int D.6255;
  char * D.6256;
  _Bool D.6257;
  long int D.6258;
  long int D.6259;
  unsigned int D.6262;
  unsigned int D.6263;
  _Bool D.6264;
  long int D.6265;
  long int D.6266;
  unsigned int D.6269;
  unsigned int D.6272;
  unsigned int D.6275;
  sizetype D.6276;
  void * D.6277;
  int D.6278;
  unsigned int D.6281;
  unsigned int D.6282;
  _Bool D.6283;
  long int D.6284;
  long int D.6285;
  struct malloc_chunk * D.6287;
  unsigned int D.6290;
  unsigned int D.6295;
  int I.36;
  unsigned int D.6297;
  unsigned int D.6298;
  unsigned int D.6299;
  int iftmp.37;
  unsigned int D.6307;
  struct malloc_chunk * * D.6308;
  _Bool D.6309;
  long int D.6310;
  long int D.6311;
  _Bool D.6313;
  long int D.6314;
  long int D.6315;
  int iftmp.38;
  _Bool D.6321;
  long int D.6322;
  long int D.6323;
  _Bool D.6325;
  long int D.6326;
  long int D.6327;
  struct malloc_tree_chunk * D.6330;
  _Bool D.6333;
  long int D.6334;
  long int D.6335;
  struct malloc_tree_chunk * D.6343;
  _Bool D.6345;
  long int D.6346;
  long int D.6347;
  unsigned int D.6353;
  struct malloc_tree_chunk * D.6354;
  unsigned int D.6359;
  int D.6360;
  unsigned int D.6361;
  unsigned int D.6362;
  unsigned int D.6363;
  _Bool D.6365;
  long int D.6366;
  long int D.6367;
  struct malloc_tree_chunk * D.6370;
  _Bool D.6377;
  long int D.6378;
  long int D.6379;
  _Bool D.6384;
  long int D.6385;
  long int D.6386;
  _Bool D.6392;
  long int D.6393;
  long int D.6394;
  unsigned int D.6400;
  unsigned int D.6401;
  unsigned int D.6404;
  unsigned int D.6405;
  struct malloc_chunk * D.6406;
  _Bool D.6407;
  long int D.6408;
  long int D.6409;
  unsigned int D.6412;
  _Bool D.6413;
  long int D.6414;
  long int D.6415;
  unsigned int D.6418;
  struct malloc_chunk * D.6421;
  unsigned int D.6424;
  unsigned int D.6425;
  unsigned int D.6426;
  unsigned int D.6429;
  unsigned int D.6434;
  unsigned int D.6435;
  unsigned int D.6436;
  struct malloc_chunk * D.6437;
  unsigned int D.6438;
  int I.39;
  unsigned int D.6444;
  unsigned int D.6445;
  unsigned int D.6446;
  int iftmp.40;
  unsigned int D.6454;
  struct malloc_chunk * * D.6455;
  _Bool D.6456;
  long int D.6457;
  long int D.6458;
  _Bool D.6460;
  long int D.6461;
  long int D.6462;
  int iftmp.41;
  _Bool D.6468;
  long int D.6469;
  long int D.6470;
  _Bool D.6472;
  long int D.6473;
  long int D.6474;
  struct malloc_tree_chunk * D.6477;
  _Bool D.6480;
  long int D.6481;
  long int D.6482;
  struct malloc_tree_chunk * D.6490;
  _Bool D.6492;
  long int D.6493;
  long int D.6494;
  unsigned int D.6500;
  struct malloc_tree_chunk * D.6501;
  int D.6506;
  unsigned int D.6507;
  unsigned int D.6508;
  unsigned int D.6509;
  _Bool D.6511;
  long int D.6512;
  long int D.6513;
  struct malloc_tree_chunk * D.6516;
  _Bool D.6523;
  long int D.6524;
  long int D.6525;
  _Bool D.6530;
  long int D.6531;
  long int D.6532;
  _Bool D.6538;
  long int D.6539;
  long int D.6540;
  unsigned int D.6548;
  unsigned int D.6551;
  int I.42;
  unsigned int D.6553;
  unsigned int D.6554;
  unsigned int D.6557;
  struct malloc_chunk * D.6559;
  _Bool D.6560;
  long int D.6561;
  long int D.6562;
  unsigned int D.6573;
  unsigned int D.6574;
  int D.6575;
  unsigned int D.6576;
  unsigned int D.6577;
  struct malloc_tree_chunk * D.6578;
  int I.43;
  unsigned int D.6580;
  unsigned int D.6581;
  unsigned int D.6584;
  struct malloc_tree_chunk * D.6585;
  int iftmp.44;
  unsigned int D.6590;
  unsigned int D.6591;
  unsigned int D.6593;
  unsigned int D.6594;
  unsigned int D.6597;
  struct malloc_tree_chunk * D.6598;
  _Bool D.6602;
  long int D.6603;
  long int D.6604;
  _Bool D.6609;
  long int D.6610;
  long int D.6611;
  _Bool D.6613;
  long int D.6614;
  long int D.6615;
  struct malloc_tree_chunk * D.6617;
  void postaction = <<< error >>>;
  void erroraction = <<< error >>>;

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

    p = mem + 4294967288;
    D.6250 = mparams.page_size;
    if (D.6250 != 0) goto <D.6246>; else goto <D.6251>;
    <D.6251>:
    D.6252 = init_mparams ();
    if (D.6252 == 0) goto <D.6246>; else goto <D.6247>;
    <D.6246>:
    D.6253 = _gm_.mflags;
    D.6254 = D.6253 & 2;
    if (D.6254 == 0) goto <D.6248>; else goto <D.6247>;
    <D.6247>:
    D.6255 = pthread_mutex_lock (&_gm_.mutex);
    if (D.6255 == 0) goto <D.6248>; else goto <D.6249>;
    <D.6248>:
    D.6256 = _gm_.least_addr;
    D.6257 = D.6256 <= p;
    D.6258 = (long int) D.6257;
    D.6259 = __builtin_expect (D.6258, 1);
    if (D.6259 != 0) goto <D.6260>; else goto <D.6261>;
    <D.6260>:
    D.6262 = p->head;
    D.6263 = D.6262 & 2;
    D.6264 = D.6263 != 0;
    D.6265 = (long int) D.6264;
    D.6266 = __builtin_expect (D.6265, 1);
    if (D.6266 != 0) goto <D.6267>; else goto <D.6268>;
    <D.6267>:
    {
      size_t psize;
      struct malloc_chunk * next;

      D.6262 = p->head;
      psize = D.6262 & 4294967292;
      next = p + psize;
      D.6262 = p->head;
      D.6269 = D.6262 & 1;
      if (D.6269 == 0) goto <D.6270>; else goto <D.6271>;
      <D.6270>:
      {
        size_t prevsize;

        prevsize = p->prev_foot;
        D.6272 = prevsize & 1;
        if (D.6272 != 0) goto <D.6273>; else goto <D.6274>;
        <D.6273>:
        prevsize = prevsize & 4294967294;
        D.6275 = prevsize + psize;
        psize = D.6275 + 16;
        D.6276 = -prevsize;
        D.6277 = p + D.6276;
        D.6278 = munmap (D.6277, psize);
        if (D.6278 == 0) goto <D.6279>; else goto <D.6280>;
        <D.6279>:
        D.6281 = _gm_.footprint;
        D.6282 = D.6281 - psize;
        _gm_.footprint = D.6282;
        <D.6280>:
        goto postaction;
        <D.6274>:
        {
          struct malloc_chunk * prev;

          D.6276 = -prevsize;
          prev = p + D.6276;
          psize = psize + prevsize;
          p = prev;
          D.6256 = _gm_.least_addr;
          D.6283 = D.6256 <= prev;
          D.6284 = (long int) D.6283;
          D.6285 = __builtin_expect (D.6284, 1);
          if (D.6285 != 0) goto <D.6286>; else goto erroraction;
          <D.6286>:
          D.6287 = _gm_.dv;
          if (D.6287 != p) goto <D.6288>; else goto <D.6289>;
          <D.6288>:
          D.6290 = prevsize >> 3;
          if (D.6290 <= 31) goto <D.6291>; else goto <D.6292>;
          <D.6291>:
          {
            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.6293>; else goto <D.6294>;
            <D.6293>:
            D.6295 = _gm_.smallmap;
            I.36 = (int) I;
            D.6297 = 1 << I.36;
            D.6298 = ~D.6297;
            D.6299 = D.6295 & D.6298;
            _gm_.smallmap = D.6299;
            goto <D.6300>;
            <D.6294>:
            D.6307 = I << 1;
            D.6308 = &_gm_.smallbins[D.6307];
            D.6309 = D.6308 == F;
            D.6310 = (long int) D.6309;
            D.6311 = __builtin_expect (D.6310, 1);
            if (D.6311 != 0) goto <D.6304>; else goto <D.6312>;
            <D.6312>:
            D.6256 = _gm_.least_addr;
            D.6313 = D.6256 <= F;
            D.6314 = (long int) D.6313;
            D.6315 = __builtin_expect (D.6314, 1);
            if (D.6315 != 0) goto <D.6304>; else goto <D.6305>;
            <D.6304>:
            iftmp.37 = 1;
            goto <D.6306>;
            <D.6305>:
            iftmp.37 = 0;
            <D.6306>:
            if (iftmp.37 != 0) goto <D.6316>; else goto <D.6301>;
            <D.6316>:
            D.6307 = I << 1;
            D.6308 = &_gm_.smallbins[D.6307];
            D.6321 = D.6308 == B;
            D.6322 = (long int) D.6321;
            D.6323 = __builtin_expect (D.6322, 1);
            if (D.6323 != 0) goto <D.6318>; else goto <D.6324>;
            <D.6324>:
            D.6256 = _gm_.least_addr;
            D.6325 = D.6256 <= B;
            D.6326 = (long int) D.6325;
            D.6327 = __builtin_expect (D.6326, 1);
            if (D.6327 != 0) goto <D.6318>; else goto <D.6319>;
            <D.6318>:
            iftmp.38 = 1;
            goto <D.6320>;
            <D.6319>:
            iftmp.38 = 0;
            <D.6320>:
            if (iftmp.38 != 0) goto <D.6328>; else goto <D.6301>;
            <D.6328>:
            F->bk = B;
            B->fd = F;
            goto <D.6302>;
            <D.6301>:
            abort ();
            <D.6302>:
            <D.6300>:
          }
          goto <D.6329>;
          <D.6292>:
          {
            struct malloc_tree_chunk * TP;

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

              XP = TP->parent;
              D.6330 = TP->bk;
              if (D.6330 != TP) goto <D.6331>; else goto <D.6332>;
              <D.6331>:
              {
                struct malloc_tree_chunk * F;

                F = TP->fd;
                R = TP->bk;
                D.6256 = _gm_.least_addr;
                D.6333 = D.6256 <= F;
                D.6334 = (long int) D.6333;
                D.6335 = __builtin_expect (D.6334, 1);
                if (D.6335 != 0) goto <D.6336>; else goto <D.6337>;
                <D.6336>:
                F->bk = R;
                R->fd = F;
                goto <D.6338>;
                <D.6337>:
                abort ();
                <D.6338>:
              }
              goto <D.6339>;
              <D.6332>:
              {
                struct malloc_tree_chunk * * RP;

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

                  goto <D.5177>;
                  <D.5176>:
                  RP = CP;
                  R = *RP;
                  <D.5177>:
                  CP = &R->child[1];
                  D.6343 = *CP;
                  if (D.6343 != 0B) goto <D.5176>; else goto <D.6344>;
                  <D.6344>:
                  CP = &R->child[0];
                  D.6343 = *CP;
                  if (D.6343 != 0B) goto <D.5176>; else goto <D.5178>;
                  <D.5178>:
                  D.6256 = _gm_.least_addr;
                  D.6345 = D.6256 <= RP;
                  D.6346 = (long int) D.6345;
                  D.6347 = __builtin_expect (D.6346, 1);
                  if (D.6347 != 0) goto <D.6348>; else goto <D.6349>;
                  <D.6348>:
                  *RP = 0B;
                  goto <D.6350>;
                  <D.6349>:
                  abort ();
                  <D.6350>:
                }
                <D.6341>:
              }
              <D.6339>:
              if (XP != 0B) goto <D.6351>; else goto <D.6352>;
              <D.6351>:
              {
                struct malloc_tree_chunk * * H;

                D.6353 = TP->index;
                H = &_gm_.treebins[D.6353];
                D.6354 = *H;
                if (D.6354 == TP) goto <D.6355>; else goto <D.6356>;
                <D.6355>:
                *H = R;
                D.6354 = *H;
                if (D.6354 == 0B) goto <D.6357>; else goto <D.6358>;
                <D.6357>:
                D.6359 = _gm_.treemap;
                D.6353 = TP->index;
                D.6360 = (int) D.6353;
                D.6361 = 1 << D.6360;
                D.6362 = ~D.6361;
                D.6363 = D.6359 & D.6362;
                _gm_.treemap = D.6363;
                <D.6358>:
                goto <D.6364>;
                <D.6356>:
                D.6256 = _gm_.least_addr;
                D.6365 = D.6256 <= XP;
                D.6366 = (long int) D.6365;
                D.6367 = __builtin_expect (D.6366, 1);
                if (D.6367 != 0) goto <D.6368>; else goto <D.6369>;
                <D.6368>:
                D.6370 = XP->child[0];
                if (D.6370 == TP) goto <D.6371>; else goto <D.6372>;
                <D.6371>:
                XP->child[0] = R;
                goto <D.6373>;
                <D.6372>:
                XP->child[1] = R;
                <D.6373>:
                goto <D.6374>;
                <D.6369>:
                abort ();
                <D.6374>:
                <D.6364>:
                if (R != 0B) goto <D.6375>; else goto <D.6376>;
                <D.6375>:
                D.6256 = _gm_.least_addr;
                D.6377 = D.6256 <= R;
                D.6378 = (long int) D.6377;
                D.6379 = __builtin_expect (D.6378, 1);
                if (D.6379 != 0) goto <D.6380>; else goto <D.6381>;
                <D.6380>:
                {
                  struct malloc_tree_chunk * C0;
                  struct malloc_tree_chunk * C1;

                  R->parent = XP;
                  C0 = TP->child[0];
                  if (C0 != 0B) goto <D.6382>; else goto <D.6383>;
                  <D.6382>:
                  D.6256 = _gm_.least_addr;
                  D.6384 = D.6256 <= C0;
                  D.6385 = (long int) D.6384;
                  D.6386 = __builtin_expect (D.6385, 1);
                  if (D.6386 != 0) goto <D.6387>; else goto <D.6388>;
                  <D.6387>:
                  R->child[0] = C0;
                  C0->parent = R;
                  goto <D.6389>;
                  <D.6388>:
                  abort ();
                  <D.6389>:
                  <D.6383>:
                  C1 = TP->child[1];
                  if (C1 != 0B) goto <D.6390>; else goto <D.6391>;
                  <D.6390>:
                  D.6256 = _gm_.least_addr;
                  D.6392 = D.6256 <= C1;
                  D.6393 = (long int) D.6392;
                  D.6394 = __builtin_expect (D.6393, 1);
                  if (D.6394 != 0) goto <D.6395>; else goto <D.6396>;
                  <D.6395>:
                  R->child[1] = C1;
                  C1->parent = R;
                  goto <D.6397>;
                  <D.6396>:
                  abort ();
                  <D.6397>:
                  <D.6391>:
                }
                goto <D.6398>;
                <D.6381>:
                abort ();
                <D.6398>:
                <D.6376>:
              }
              <D.6352>:
            }
          }
          <D.6329>:
          goto <D.6399>;
          <D.6289>:
          D.6400 = next->head;
          D.6401 = D.6400 & 3;
          if (D.6401 == 3) goto <D.6402>; else goto <D.6403>;
          <D.6402>:
          _gm_.dvsize = psize;
          D.6400 = next->head;
          D.6404 = D.6400 & 4294967294;
          next->head = D.6404;
          D.6405 = psize | 1;
          p->head = D.6405;
          D.6406 = p + psize;
          D.6406->prev_foot = psize;
          goto postaction;
          <D.6403>:
          <D.6399>:
        }
      }
      <D.6271>:
      D.6407 = p < next;
      D.6408 = (long int) D.6407;
      D.6409 = __builtin_expect (D.6408, 1);
      if (D.6409 != 0) goto <D.6410>; else goto <D.6411>;
      <D.6410>:
      D.6400 = next->head;
      D.6412 = D.6400 & 1;
      D.6413 = D.6412 != 0;
      D.6414 = (long int) D.6413;
      D.6415 = __builtin_expect (D.6414, 1);
      if (D.6415 != 0) goto <D.6416>; else goto <D.6417>;
      <D.6416>:
      D.6400 = next->head;
      D.6418 = D.6400 & 2;
      if (D.6418 == 0) goto <D.6419>; else goto <D.6420>;
      <D.6419>:
      D.6421 = _gm_.top;
      if (D.6421 == next) goto <D.6422>; else goto <D.6423>;
      <D.6422>:
      {
        size_t tsize;

        D.6424 = _gm_.topsize;
        D.6425 = D.6424 + psize;
        _gm_.topsize = D.6425;
        tsize = _gm_.topsize;
        _gm_.top = p;
        D.6426 = tsize | 1;
        p->head = D.6426;
        D.6287 = _gm_.dv;
        if (D.6287 == p) goto <D.6427>; else goto <D.6428>;
        <D.6427>:
        _gm_.dv = 0B;
        _gm_.dvsize = 0;
        <D.6428>:
        D.6429 = _gm_.trim_check;
        if (D.6429 < tsize) goto <D.6430>; else goto <D.6431>;
        <D.6430>:
        sys_trim (&_gm_, 0);
        <D.6431>:
        goto postaction;
      }
      <D.6423>:
      D.6287 = _gm_.dv;
      if (D.6287 == next) goto <D.6432>; else goto <D.6433>;
      <D.6432>:
      {
        size_t dsize;

        D.6434 = _gm_.dvsize;
        D.6435 = D.6434 + psize;
        _gm_.dvsize = D.6435;
        dsize = _gm_.dvsize;
        _gm_.dv = p;
        D.6436 = dsize | 1;
        p->head = D.6436;
        D.6437 = p + dsize;
        D.6437->prev_foot = dsize;
        goto postaction;
      }
      <D.6433>:
      {
        size_t nsize;

        D.6400 = next->head;
        nsize = D.6400 & 4294967292;
        psize = psize + nsize;
        D.6438 = nsize >> 3;
        if (D.6438 <= 31) goto <D.6439>; else goto <D.6440>;
        <D.6439>:
        {
          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.6441>; else goto <D.6442>;
          <D.6441>:
          D.6295 = _gm_.smallmap;
          I.39 = (int) I;
          D.6444 = 1 << I.39;
          D.6445 = ~D.6444;
          D.6446 = D.6295 & D.6445;
          _gm_.smallmap = D.6446;
          goto <D.6447>;
          <D.6442>:
          D.6454 = I << 1;
          D.6455 = &_gm_.smallbins[D.6454];
          D.6456 = D.6455 == F;
          D.6457 = (long int) D.6456;
          D.6458 = __builtin_expect (D.6457, 1);
          if (D.6458 != 0) goto <D.6451>; else goto <D.6459>;
          <D.6459>:
          D.6256 = _gm_.least_addr;
          D.6460 = D.6256 <= F;
          D.6461 = (long int) D.6460;
          D.6462 = __builtin_expect (D.6461, 1);
          if (D.6462 != 0) goto <D.6451>; else goto <D.6452>;
          <D.6451>:
          iftmp.40 = 1;
          goto <D.6453>;
          <D.6452>:
          iftmp.40 = 0;
          <D.6453>:
          if (iftmp.40 != 0) goto <D.6463>; else goto <D.6448>;
          <D.6463>:
          D.6454 = I << 1;
          D.6455 = &_gm_.smallbins[D.6454];
          D.6468 = D.6455 == B;
          D.6469 = (long int) D.6468;
          D.6470 = __builtin_expect (D.6469, 1);
          if (D.6470 != 0) goto <D.6465>; else goto <D.6471>;
          <D.6471>:
          D.6256 = _gm_.least_addr;
          D.6472 = D.6256 <= B;
          D.6473 = (long int) D.6472;
          D.6474 = __builtin_expect (D.6473, 1);
          if (D.6474 != 0) goto <D.6465>; else goto <D.6466>;
          <D.6465>:
          iftmp.41 = 1;
          goto <D.6467>;
          <D.6466>:
          iftmp.41 = 0;
          <D.6467>:
          if (iftmp.41 != 0) goto <D.6475>; else goto <D.6448>;
          <D.6475>:
          F->bk = B;
          B->fd = F;
          goto <D.6449>;
          <D.6448>:
          abort ();
          <D.6449>:
          <D.6447>:
        }
        goto <D.6476>;
        <D.6440>:
        {
          struct malloc_tree_chunk * TP;

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

            XP = TP->parent;
            D.6477 = TP->bk;
            if (D.6477 != TP) goto <D.6478>; else goto <D.6479>;
            <D.6478>:
            {
              struct malloc_tree_chunk * F;

              F = TP->fd;
              R = TP->bk;
              D.6256 = _gm_.least_addr;
              D.6480 = D.6256 <= F;
              D.6481 = (long int) D.6480;
              D.6482 = __builtin_expect (D.6481, 1);
              if (D.6482 != 0) goto <D.6483>; else goto <D.6484>;
              <D.6483>:
              F->bk = R;
              R->fd = F;
              goto <D.6485>;
              <D.6484>:
              abort ();
              <D.6485>:
            }
            goto <D.6486>;
            <D.6479>:
            {
              struct malloc_tree_chunk * * RP;

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

                goto <D.5196>;
                <D.5195>:
                RP = CP;
                R = *RP;
                <D.5196>:
                CP = &R->child[1];
                D.6490 = *CP;
                if (D.6490 != 0B) goto <D.5195>; else goto <D.6491>;
                <D.6491>:
                CP = &R->child[0];
                D.6490 = *CP;
                if (D.6490 != 0B) goto <D.5195>; else goto <D.5197>;
                <D.5197>:
                D.6256 = _gm_.least_addr;
                D.6492 = D.6256 <= RP;
                D.6493 = (long int) D.6492;
                D.6494 = __builtin_expect (D.6493, 1);
                if (D.6494 != 0) goto <D.6495>; else goto <D.6496>;
                <D.6495>:
                *RP = 0B;
                goto <D.6497>;
                <D.6496>:
                abort ();
                <D.6497>:
              }
              <D.6488>:
            }
            <D.6486>:
            if (XP != 0B) goto <D.6498>; else goto <D.6499>;
            <D.6498>:
            {
              struct malloc_tree_chunk * * H;

              D.6500 = TP->index;
              H = &_gm_.treebins[D.6500];
              D.6501 = *H;
              if (D.6501 == TP) goto <D.6502>; else goto <D.6503>;
              <D.6502>:
              *H = R;
              D.6501 = *H;
              if (D.6501 == 0B) goto <D.6504>; else goto <D.6505>;
              <D.6504>:
              D.6359 = _gm_.treemap;
              D.6500 = TP->index;
              D.6506 = (int) D.6500;
              D.6507 = 1 << D.6506;
              D.6508 = ~D.6507;
              D.6509 = D.6359 & D.6508;
              _gm_.treemap = D.6509;
              <D.6505>:
              goto <D.6510>;
              <D.6503>:
              D.6256 = _gm_.least_addr;
              D.6511 = D.6256 <= XP;
              D.6512 = (long int) D.6511;
              D.6513 = __builtin_expect (D.6512, 1);
              if (D.6513 != 0) goto <D.6514>; else goto <D.6515>;
              <D.6514>:
              D.6516 = XP->child[0];
              if (D.6516 == TP) goto <D.6517>; else goto <D.6518>;
              <D.6517>:
              XP->child[0] = R;
              goto <D.6519>;
              <D.6518>:
              XP->child[1] = R;
              <D.6519>:
              goto <D.6520>;
              <D.6515>:
              abort ();
              <D.6520>:
              <D.6510>:
              if (R != 0B) goto <D.6521>; else goto <D.6522>;
              <D.6521>:
              D.6256 = _gm_.least_addr;
              D.6523 = D.6256 <= R;
              D.6524 = (long int) D.6523;
              D.6525 = __builtin_expect (D.6524, 1);
              if (D.6525 != 0) goto <D.6526>; else goto <D.6527>;
              <D.6526>:
              {
                struct malloc_tree_chunk * C0;
                struct malloc_tree_chunk * C1;

                R->parent = XP;
                C0 = TP->child[0];
                if (C0 != 0B) goto <D.6528>; else goto <D.6529>;
                <D.6528>:
                D.6256 = _gm_.least_addr;
                D.6530 = D.6256 <= C0;
                D.6531 = (long int) D.6530;
                D.6532 = __builtin_expect (D.6531, 1);
                if (D.6532 != 0) goto <D.6533>; else goto <D.6534>;
                <D.6533>:
                R->child[0] = C0;
                C0->parent = R;
                goto <D.6535>;
                <D.6534>:
                abort ();
                <D.6535>:
                <D.6529>:
                C1 = TP->child[1];
                if (C1 != 0B) goto <D.6536>; else goto <D.6537>;
                <D.6536>:
                D.6256 = _gm_.least_addr;
                D.6538 = D.6256 <= C1;
                D.6539 = (long int) D.6538;
                D.6540 = __builtin_expect (D.6539, 1);
                if (D.6540 != 0) goto <D.6541>; else goto <D.6542>;
                <D.6541>:
                R->child[1] = C1;
                C1->parent = R;
                goto <D.6543>;
                <D.6542>:
                abort ();
                <D.6543>:
                <D.6537>:
              }
              goto <D.6544>;
              <D.6527>:
              abort ();
              <D.6544>:
              <D.6522>:
            }
            <D.6499>:
          }
        }
        <D.6476>:
        D.6405 = psize | 1;
        p->head = D.6405;
        D.6406 = p + psize;
        D.6406->prev_foot = psize;
        D.6287 = _gm_.dv;
        if (D.6287 == p) goto <D.6545>; else goto <D.6546>;
        <D.6545>:
        _gm_.dvsize = psize;
        goto postaction;
        <D.6546>:
      }
      goto <D.6547>;
      <D.6420>:
      D.6400 = next->head;
      D.6404 = D.6400 & 4294967294;
      next->head = D.6404;
      D.6405 = psize | 1;
      p->head = D.6405;
      D.6406 = p + psize;
      D.6406->prev_foot = psize;
      <D.6547>:
      D.6548 = psize >> 3;
      if (D.6548 <= 31) goto <D.6549>; else goto <D.6550>;
      <D.6549>:
      {
        bindex_t I;
        struct malloc_chunk * B;
        struct malloc_chunk * F;

        I = psize >> 3;
        D.6551 = I << 1;
        B = &_gm_.smallbins[D.6551];
        F = B;
        D.6295 = _gm_.smallmap;
        I.42 = (int) I;
        D.6553 = 1 << I.42;
        D.6554 = D.6295 & D.6553;
        if (D.6554 == 0) goto <D.6555>; else goto <D.6556>;
        <D.6555>:
        D.6295 = _gm_.smallmap;
        I.42 = (int) I;
        D.6553 = 1 << I.42;
        D.6557 = D.6295 | D.6553;
        _gm_.smallmap = D.6557;
        goto <D.6558>;
        <D.6556>:
        D.6559 = B->fd;
        D.6256 = _gm_.least_addr;
        D.6560 = D.6559 >= D.6256;
        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>:
        F = B->fd;
        goto <D.6565>;
        <D.6564>:
        abort ();
        <D.6565>:
        <D.6558>:
        B->fd = p;
        F->bk = p;
        p->fd = F;
        p->bk = B;
      }
      goto <D.6566>;
      <D.6550>:
      {
        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.6567>; else goto <D.6568>;
            <D.6567>:
            I = 0;
            goto <D.6569>;
            <D.6568>:
            if (X > 65535) goto <D.6570>; else goto <D.6571>;
            <D.6570>:
            I = 31;
            goto <D.6572>;
            <D.6571>:
            {
              unsigned int K;

              __asm__("bsrl %1,%0
	" : "=r" K : "rm" X);
              D.6573 = K << 1;
              D.6574 = K + 7;
              D.6575 = (int) D.6574;
              D.6576 = psize >> D.6575;
              D.6577 = D.6576 & 1;
              I = D.6573 + D.6577;
            }
            <D.6572>:
            <D.6569>:
          }
          H = &_gm_.treebins[I];
          TP->index = I;
          TP->child[1] = 0B;
          D.6578 = TP->child[1];
          TP->child[0] = D.6578;
          D.6359 = _gm_.treemap;
          I.43 = (int) I;
          D.6580 = 1 << I.43;
          D.6581 = D.6359 & D.6580;
          if (D.6581 == 0) goto <D.6582>; else goto <D.6583>;
          <D.6582>:
          D.6359 = _gm_.treemap;
          I.43 = (int) I;
          D.6580 = 1 << I.43;
          D.6584 = D.6359 | D.6580;
          _gm_.treemap = D.6584;
          *H = TP;
          TP->parent = H;
          TP->bk = TP;
          D.6585 = TP->bk;
          TP->fd = D.6585;
          goto <D.6586>;
          <D.6583>:
          {
            struct malloc_tree_chunk * T;
            size_t K;

            T = *H;
            if (I != 31) goto <D.6588>; else goto <D.6589>;
            <D.6588>:
            D.6590 = I >> 1;
            D.6591 = 25 - D.6590;
            iftmp.44 = (int) D.6591;
            goto <D.6592>;
            <D.6589>:
            iftmp.44 = 0;
            <D.6592>:
            K = psize << iftmp.44;
            <D.5214>:
            D.6593 = T->head;
            D.6594 = D.6593 & 4294967292;
            if (D.6594 != psize) goto <D.6595>; else goto <D.6596>;
            <D.6595>:
            {
              struct malloc_tree_chunk * * C;

              D.6597 = K >> 31;
              C = &T->child[D.6597];
              K = K << 1;
              D.6598 = *C;
              if (D.6598 != 0B) goto <D.6599>; else goto <D.6600>;
              <D.6599>:
              T = *C;
              goto <D.6601>;
              <D.6600>:
              D.6256 = _gm_.least_addr;
              D.6602 = D.6256 <= C;
              D.6603 = (long int) D.6602;
              D.6604 = __builtin_expect (D.6603, 1);
              if (D.6604 != 0) goto <D.6605>; else goto <D.6606>;
              <D.6605>:
              *C = TP;
              TP->parent = T;
              TP->bk = TP;
              D.6585 = TP->bk;
              TP->fd = D.6585;
              goto <D.5212>;
              <D.6606>:
              abort ();
              <D.6601>:
            }
            goto <D.6607>;
            <D.6596>:
            {
              struct malloc_tree_chunk * F;

              F = T->fd;
              D.6256 = _gm_.least_addr;
              D.6609 = D.6256 <= T;
              D.6610 = (long int) D.6609;
              D.6611 = __builtin_expect (D.6610, 1);
              if (D.6611 != 0) goto <D.6612>; else goto <D.6608>;
              <D.6612>:
              D.6256 = _gm_.least_addr;
              D.6613 = D.6256 <= F;
              D.6614 = (long int) D.6613;
              D.6615 = __builtin_expect (D.6614, 1);
              if (D.6615 != 0) goto <D.6616>; else goto <D.6608>;
              <D.6616>:
              F->bk = TP;
              D.6617 = F->bk;
              T->fd = D.6617;
              TP->fd = F;
              TP->bk = T;
              TP->parent = 0B;
              goto <D.5212>;
              <D.6608>:
              abort ();
            }
            <D.6607>:
            goto <D.5214>;
            <D.5212>:
          }
          <D.6586>:
        }
      }
      <D.6566>:
      goto postaction;
      <D.6417>:
      <D.6411>:
    }
    <D.6268>:
    <D.6261>:
    erroraction:
    abort ();
    postaction:
    D.6253 = _gm_.mflags;
    D.6254 = D.6253 & 2;
    if (D.6254 != 0) goto <D.6618>; else goto <D.6619>;
    <D.6618>:
    pthread_mutex_unlock (&_gm_.mutex);
    <D.6619>:
    <D.6249>:
  }
  <D.6245>:
}


sys_trim (struct malloc_state * m, size_t pad)
{
  struct malloc_chunk * D.6622;
  unsigned int D.6625;
  unsigned int D.6628;
  unsigned int D.6629;
  unsigned int D.6630;
  unsigned int D.6631;
  unsigned int D.6632;
  unsigned int D.6633;
  unsigned int D.6634;
  unsigned int D.6637;
  unsigned int D.6640;
  int D.6643;
  char * D.6648;
  void * D.6649;
  void * D.6651;
  int D.6652;
  char * D.6658;
  _Bool D.6661;
  _Bool D.6662;
  _Bool D.6663;
  int old_br.45;
  int new_br.46;
  int D.6668;
  unsigned int D.6671;
  unsigned int D.6672;
  unsigned int D.6673;
  unsigned int D.6674;
  unsigned int D.6677;
  int D.6680;
  _Bool D.6681;
  size_t released;

  released = 0;
  if (pad <= 4294967231) goto <D.6620>; else goto <D.6621>;
  <D.6620>:
  D.6622 = m->top;
  if (D.6622 != 0B) goto <D.6623>; else goto <D.6624>;
  <D.6623>:
  pad = pad + 40;
  D.6625 = m->topsize;
  if (D.6625 > pad) goto <D.6626>; else goto <D.6627>;
  <D.6626>:
  {
    size_t unit;
    size_t extra;
    struct malloc_segment * sp;

    unit = mparams.granularity;
    D.6625 = m->topsize;
    D.6628 = D.6625 - pad;
    D.6629 = D.6628 + unit;
    D.6630 = D.6629 + 4294967295;
    D.6631 = D.6630 / unit;
    D.6632 = D.6631 + 4294967295;
    extra = D.6632 * unit;
    D.6622 = m->top;
    sp = segment_holding (m, D.6622);
    D.6633 = sp->sflags;
    D.6634 = D.6633 & 8;
    if (D.6634 == 0) goto <D.6635>; else goto <D.6636>;
    <D.6635>:
    D.6633 = sp->sflags;
    D.6637 = D.6633 & 1;
    if (D.6637 != 0) goto <D.6638>; else goto <D.6639>;
    <D.6638>:
    D.6640 = sp->size;
    if (D.6640 >= extra) goto <D.6641>; else goto <D.6642>;
    <D.6641>:
    D.6643 = has_segment_link (m, sp);
    if (D.6643 == 0) goto <D.6644>; else goto <D.6645>;
    <D.6644>:
    {
      size_t newsize;

      D.6640 = sp->size;
      newsize = D.6640 - extra;
      D.6640 = sp->size;
      D.6648 = sp->base;
      D.6649 = mremap (D.6648, D.6640, newsize, 0);
      if (D.6649 != 4294967295B) goto <D.6646>; else goto <D.6650>;
      <D.6650>:
      D.6648 = sp->base;
      D.6651 = D.6648 + newsize;
      D.6652 = munmap (D.6651, extra);
      if (D.6652 == 0) goto <D.6646>; else goto <D.6647>;
      <D.6646>:
      released = extra;
      <D.6647>:
    }
    <D.6645>:
    <D.6642>:
    goto <D.6653>;
    <D.6639>:
    if (0 != 0) goto <D.6654>; else goto <D.6655>;
    <D.6654>:
    if (extra > 2147483646) goto <D.6656>; else goto <D.6657>;
    <D.6656>:
    extra = 2147483648 - unit;
    <D.6657>:
    {
      char * old_br;

      old_br = 4294967295B;
      D.6648 = sp->base;
      D.6640 = sp->size;
      D.6658 = D.6648 + D.6640;
      if (D.6658 == old_br) goto <D.6659>; else goto <D.6660>;
      <D.6659>:
      {
        char * rel_br;
        char * new_br;

        rel_br = 4294967295B;
        new_br = 4294967295B;
        D.6661 = rel_br != 4294967295B;
        D.6662 = new_br < old_br;
        D.6663 = D.6661 & D.6662;
        if (D.6663 != 0) goto <D.6664>; else goto <D.6665>;
        <D.6664>:
        old_br.45 = (int) old_br;
        new_br.46 = (int) new_br;
        D.6668 = old_br.45 - new_br.46;
        released = (size_t) D.6668;
        <D.6665>:
      }
      <D.6660>:
    }
    <D.6655>:
    <D.6653>:
    <D.6636>:
    if (released != 0) goto <D.6669>; else goto <D.6670>;
    <D.6669>:
    D.6640 = sp->size;
    D.6671 = D.6640 - released;
    sp->size = D.6671;
    D.6672 = m->footprint;
    D.6673 = D.6672 - released;
    m->footprint = D.6673;
    D.6625 = m->topsize;
    D.6674 = D.6625 - released;
    D.6622 = m->top;
    init_top (m, D.6622, D.6674);
    <D.6670>:
  }
  <D.6627>:
  if (1 != 0) goto <D.6675>; else goto <D.6676>;
  <D.6675>:
  D.6677 = release_unused_segments (m);
  released = D.6677 + released;
  <D.6676>:
  if (released == 0) goto <D.6678>; else goto <D.6679>;
  <D.6678>:
  m->trim_check = 4294967295;
  <D.6679>:
  <D.6624>:
  <D.6621>:
  D.6681 = released != 0;
  D.6680 = (int) D.6681;
  return D.6680;
}


has_segment_link (struct malloc_state * m, struct malloc_segment * ss)
{
  char * D.6683;
  unsigned int D.6686;
  char * D.6687;
  int D.6690;
  struct malloc_segment * sp;

  sp = &m->seg;
  <D.4831>:
  D.6683 = ss->base;
  if (D.6683 <= sp) goto <D.6684>; else goto <D.6685>;
  <D.6684>:
  D.6683 = ss->base;
  D.6686 = ss->size;
  D.6687 = D.6683 + D.6686;
  if (D.6687 > sp) goto <D.6688>; else goto <D.6689>;
  <D.6688>:
  D.6690 = 1;
  return D.6690;
  <D.6689>:
  <D.6685>:
  sp = sp->next;
  if (sp == 0B) goto <D.6691>; else goto <D.6692>;
  <D.6691>:
  D.6690 = 0;
  return D.6690;
  <D.6692>:
  goto <D.4831>;
}


release_unused_segments (struct malloc_state * m)
{
  unsigned int D.6694;
  unsigned int D.6695;
  sizetype iftmp.47;
  void * D.6699;
  unsigned int D.6700;
  unsigned int D.6701;
  unsigned int D.6704;
  unsigned int D.6706;
  unsigned int D.6707;
  char * D.6710;
  sizetype D.6711;
  char * D.6712;
  struct malloc_chunk * D.6715;
  struct malloc_tree_chunk * D.6719;
  char * D.6722;
  _Bool D.6723;
  long int D.6724;
  long int D.6725;
  struct malloc_tree_chunk * D.6733;
  _Bool D.6735;
  long int D.6736;
  long int D.6737;
  unsigned int D.6743;
  struct malloc_tree_chunk * D.6744;
  unsigned int D.6749;
  int D.6750;
  unsigned int D.6751;
  unsigned int D.6752;
  unsigned int D.6753;
  _Bool D.6755;
  long int D.6756;
  long int D.6757;
  struct malloc_tree_chunk * D.6760;
  _Bool D.6767;
  long int D.6768;
  long int D.6769;
  _Bool D.6774;
  long int D.6775;
  long int D.6776;
  _Bool D.6782;
  long int D.6783;
  long int D.6784;
  int D.6789;
  unsigned int D.6792;
  unsigned int D.6793;
  unsigned int D.6801;
  unsigned int D.6802;
  int D.6803;
  unsigned int D.6804;
  unsigned int D.6805;
  struct malloc_tree_chunk * D.6806;
  int I.48;
  unsigned int D.6808;
  unsigned int D.6809;
  unsigned int D.6812;
  int iftmp.49;
  unsigned int D.6817;
  unsigned int D.6818;
  unsigned int D.6820;
  unsigned int D.6821;
  unsigned int D.6824;
  struct malloc_tree_chunk * D.6825;
  _Bool D.6829;
  long int D.6830;
  long int D.6831;
  _Bool D.6836;
  long int D.6837;
  long int D.6838;
  _Bool D.6840;
  long int D.6841;
  long int D.6842;
  struct malloc_tree_chunk * D.6844;
  size_t D.6845;
  size_t released;
  struct malloc_segment * pred;
  struct malloc_segment * sp;

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

    base = sp->base;
    size = sp->size;
    next = sp->next;
    D.6694 = BIT_FIELD_REF <*sp, 32, 96>;
    D.6695 = D.6694 & 9;
    if (D.6695 == 1) goto <D.6696>; else goto <D.6697>;
    <D.6696>:
    {
      struct malloc_chunk * p;
      size_t psize;

      D.6699 = base + 8;
      D.6700 = (unsigned int) D.6699;
      D.6701 = D.6700 & 7;
      if (D.6701 != 0) goto <D.6702>; else goto <D.6703>;
      <D.6702>:
      D.6699 = base + 8;
      D.6700 = (unsigned int) D.6699;
      D.6704 = -D.6700;
      iftmp.47 = D.6704 & 7;
      goto <D.6705>;
      <D.6703>:
      iftmp.47 = 0;
      <D.6705>:
      p = base + iftmp.47;
      D.6706 = p->head;
      psize = D.6706 & 4294967292;
      D.6706 = p->head;
      D.6707 = D.6706 & 2;
      if (D.6707 == 0) goto <D.6708>; else goto <D.6709>;
      <D.6708>:
      D.6710 = p + psize;
      D.6711 = size + 4294967256;
      D.6712 = base + D.6711;
      if (D.6710 >= D.6712) goto <D.6713>; else goto <D.6714>;
      <D.6713>:
      {
        struct malloc_tree_chunk * tp;

        tp = p;
        D.6715 = m->dv;
        if (D.6715 == p) goto <D.6716>; else goto <D.6717>;
        <D.6716>:
        m->dv = 0B;
        m->dvsize = 0;
        goto <D.6718>;
        <D.6717>:
        {
          struct malloc_tree_chunk * XP;
          struct malloc_tree_chunk * R;

          XP = tp->parent;
          D.6719 = tp->bk;
          if (D.6719 != tp) goto <D.6720>; else goto <D.6721>;
          <D.6720>:
          {
            struct malloc_tree_chunk * F;

            F = tp->fd;
            R = tp->bk;
            D.6722 = m->least_addr;
            D.6723 = D.6722 <= F;
            D.6724 = (long int) D.6723;
            D.6725 = __builtin_expect (D.6724, 1);
            if (D.6725 != 0) goto <D.6726>; else goto <D.6727>;
            <D.6726>:
            F->bk = R;
            R->fd = F;
            goto <D.6728>;
            <D.6727>:
            abort ();
            <D.6728>:
          }
          goto <D.6729>;
          <D.6721>:
          {
            struct malloc_tree_chunk * * RP;

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

              goto <D.4992>;
              <D.4991>:
              RP = CP;
              R = *RP;
              <D.4992>:
              CP = &R->child[1];
              D.6733 = *CP;
              if (D.6733 != 0B) goto <D.4991>; else goto <D.6734>;
              <D.6734>:
              CP = &R->child[0];
              D.6733 = *CP;
              if (D.6733 != 0B) goto <D.4991>; else goto <D.4993>;
              <D.4993>:
              D.6722 = m->least_addr;
              D.6735 = D.6722 <= RP;
              D.6736 = (long int) D.6735;
              D.6737 = __builtin_expect (D.6736, 1);
              if (D.6737 != 0) goto <D.6738>; else goto <D.6739>;
              <D.6738>:
              *RP = 0B;
              goto <D.6740>;
              <D.6739>:
              abort ();
              <D.6740>:
            }
            <D.6731>:
          }
          <D.6729>:
          if (XP != 0B) goto <D.6741>; else goto <D.6742>;
          <D.6741>:
          {
            struct malloc_tree_chunk * * H;

            D.6743 = tp->index;
            H = &m->treebins[D.6743];
            D.6744 = *H;
            if (D.6744 == tp) goto <D.6745>; else goto <D.6746>;
            <D.6745>:
            *H = R;
            D.6744 = *H;
            if (D.6744 == 0B) goto <D.6747>; else goto <D.6748>;
            <D.6747>:
            D.6749 = m->treemap;
            D.6743 = tp->index;
            D.6750 = (int) D.6743;
            D.6751 = 1 << D.6750;
            D.6752 = ~D.6751;
            D.6753 = D.6749 & D.6752;
            m->treemap = D.6753;
            <D.6748>:
            goto <D.6754>;
            <D.6746>:
            D.6722 = m->least_addr;
            D.6755 = D.6722 <= XP;
            D.6756 = (long int) D.6755;
            D.6757 = __builtin_expect (D.6756, 1);
            if (D.6757 != 0) goto <D.6758>; else goto <D.6759>;
            <D.6758>:
            D.6760 = XP->child[0];
            if (D.6760 == tp) goto <D.6761>; else goto <D.6762>;
            <D.6761>:
            XP->child[0] = R;
            goto <D.6763>;
            <D.6762>:
            XP->child[1] = R;
            <D.6763>:
            goto <D.6764>;
            <D.6759>:
            abort ();
            <D.6764>:
            <D.6754>:
            if (R != 0B) goto <D.6765>; else goto <D.6766>;
            <D.6765>:
            D.6722 = m->least_addr;
            D.6767 = D.6722 <= R;
            D.6768 = (long int) D.6767;
            D.6769 = __builtin_expect (D.6768, 1);
            if (D.6769 != 0) goto <D.6770>; else goto <D.6771>;
            <D.6770>:
            {
              struct malloc_tree_chunk * C0;
              struct malloc_tree_chunk * C1;

              R->parent = XP;
              C0 = tp->child[0];
              if (C0 != 0B) goto <D.6772>; else goto <D.6773>;
              <D.6772>:
              D.6722 = m->least_addr;
              D.6774 = D.6722 <= C0;
              D.6775 = (long int) D.6774;
              D.6776 = __builtin_expect (D.6775, 1);
              if (D.6776 != 0) goto <D.6777>; else goto <D.6778>;
              <D.6777>:
              R->child[0] = C0;
              C0->parent = R;
              goto <D.6779>;
              <D.6778>:
              abort ();
              <D.6779>:
              <D.6773>:
              C1 = tp->child[1];
              if (C1 != 0B) goto <D.6780>; else goto <D.6781>;
              <D.6780>:
              D.6722 = m->least_addr;
              D.6782 = D.6722 <= C1;
              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>:
              R->child[1] = C1;
              C1->parent = R;
              goto <D.6787>;
              <D.6786>:
              abort ();
              <D.6787>:
              <D.6781>:
            }
            goto <D.6788>;
            <D.6771>:
            abort ();
            <D.6788>:
            <D.6766>:
          }
          <D.6742>:
        }
        <D.6718>:
        D.6789 = munmap (base, size);
        if (D.6789 == 0) goto <D.6790>; else goto <D.6791>;
        <D.6790>:
        released = released + size;
        D.6792 = m->footprint;
        D.6793 = D.6792 - size;
        m->footprint = D.6793;
        sp = pred;
        sp->next = next;
        goto <D.6794>;
        <D.6791>:
        {
          struct malloc_tree_chunk * * H;
          bindex_t I;

          {
            size_t X;

            X = psize >> 8;
            if (X == 0) goto <D.6795>; else goto <D.6796>;
            <D.6795>:
            I = 0;
            goto <D.6797>;
            <D.6796>:
            if (X > 65535) goto <D.6798>; else goto <D.6799>;
            <D.6798>:
            I = 31;
            goto <D.6800>;
            <D.6799>:
            {
              unsigned int K;

              __asm__("bsrl %1,%0
	" : "=r" K : "rm" X);
              D.6801 = K << 1;
              D.6802 = K + 7;
              D.6803 = (int) D.6802;
              D.6804 = psize >> D.6803;
              D.6805 = D.6804 & 1;
              I = D.6801 + D.6805;
            }
            <D.6800>:
            <D.6797>:
          }
          H = &m->treebins[I];
          tp->index = I;
          tp->child[1] = 0B;
          D.6806 = tp->child[1];
          tp->child[0] = D.6806;
          D.6749 = m->treemap;
          I.48 = (int) I;
          D.6808 = 1 << I.48;
          D.6809 = D.6749 & D.6808;
          if (D.6809 == 0) goto <D.6810>; else goto <D.6811>;
          <D.6810>:
          D.6749 = m->treemap;
          I.48 = (int) I;
          D.6808 = 1 << I.48;
          D.6812 = D.6749 | D.6808;
          m->treemap = D.6812;
          *H = tp;
          tp->parent = H;
          tp->bk = tp;
          D.6719 = tp->bk;
          tp->fd = D.6719;
          goto <D.6813>;
          <D.6811>:
          {
            struct malloc_tree_chunk * T;
            size_t K;

            T = *H;
            if (I != 31) goto <D.6815>; else goto <D.6816>;
            <D.6815>:
            D.6817 = I >> 1;
            D.6818 = 25 - D.6817;
            iftmp.49 = (int) D.6818;
            goto <D.6819>;
            <D.6816>:
            iftmp.49 = 0;
            <D.6819>:
            K = psize << iftmp.49;
            <D.5006>:
            D.6820 = T->head;
            D.6821 = D.6820 & 4294967292;
            if (D.6821 != psize) goto <D.6822>; else goto <D.6823>;
            <D.6822>:
            {
              struct malloc_tree_chunk * * C;

              D.6824 = K >> 31;
              C = &T->child[D.6824];
              K = K << 1;
              D.6825 = *C;
              if (D.6825 != 0B) goto <D.6826>; else goto <D.6827>;
              <D.6826>:
              T = *C;
              goto <D.6828>;
              <D.6827>:
              D.6722 = m->least_addr;
              D.6829 = D.6722 <= C;
              D.6830 = (long int) D.6829;
              D.6831 = __builtin_expect (D.6830, 1);
              if (D.6831 != 0) goto <D.6832>; else goto <D.6833>;
              <D.6832>:
              *C = tp;
              tp->parent = T;
              tp->bk = tp;
              D.6719 = tp->bk;
              tp->fd = D.6719;
              goto <D.5004>;
              <D.6833>:
              abort ();
              <D.6828>:
            }
            goto <D.6834>;
            <D.6823>:
            {
              struct malloc_tree_chunk * F;

              F = T->fd;
              D.6722 = m->least_addr;
              D.6836 = D.6722 <= T;
              D.6837 = (long int) D.6836;
              D.6838 = __builtin_expect (D.6837, 1);
              if (D.6838 != 0) goto <D.6839>; else goto <D.6835>;
              <D.6839>:
              D.6722 = m->least_addr;
              D.6840 = D.6722 <= F;
              D.6841 = (long int) D.6840;
              D.6842 = __builtin_expect (D.6841, 1);
              if (D.6842 != 0) goto <D.6843>; else goto <D.6835>;
              <D.6843>:
              F->bk = tp;
              D.6844 = F->bk;
              T->fd = D.6844;
              tp->fd = F;
              tp->bk = T;
              tp->parent = 0B;
              goto <D.5004>;
              <D.6835>:
              abort ();
            }
            <D.6834>:
            goto <D.5006>;
            <D.5004>:
          }
          <D.6813>:
        }
        <D.6794>:
      }
      <D.6714>:
      <D.6709>:
    }
    <D.6697>:
    pred = sp;
    sp = next;
  }
  <D.5008>:
  if (sp != 0B) goto <D.5007>; else goto <D.5009>;
  <D.5009>:
  D.6845 = released;
  return D.6845;
}


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

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


internal_memalign (struct malloc_state * m, size_t alignment, size_t bytes)
{
  void * D.6851;
  unsigned int D.6854;
  unsigned int D.6855;
  unsigned int D.6858;
  int * D.6863;
  unsigned int iftmp.50;
  unsigned int D.6868;
  unsigned int D.6870;
  unsigned int D.6876;
  int D.6878;
  unsigned int D.6879;
  unsigned int D.6880;
  union pthread_mutex_t * D.6881;
  int D.6882;
  unsigned int mem.51;
  unsigned int D.6886;
  sizetype D.6889;
  char * D.6890;
  unsigned int D.6891;
  unsigned int D.6892;
  unsigned int D.6893;
  sizetype D.6894;
  char * iftmp.52;
  int br.53;
  int p.54;
  int D.6898;
  unsigned int D.6899;
  int pos.55;
  int D.6904;
  unsigned int D.6905;
  unsigned int D.6906;
  unsigned int D.6909;
  unsigned int D.6911;
  unsigned int D.6912;
  unsigned int D.6914;
  unsigned int D.6915;
  unsigned int D.6916;
  unsigned int D.6917;
  unsigned int D.6918;
  unsigned int D.6919;
  struct malloc_chunk * D.6920;
  unsigned int D.6921;
  unsigned int D.6922;
  unsigned int D.6923;
  unsigned int D.6924;
  struct malloc_chunk * D.6925;
  unsigned int D.6926;
  unsigned int D.6927;
  unsigned int D.6931;
  unsigned int D.6934;
  unsigned int D.6935;
  struct malloc_chunk * D.6936;
  unsigned int D.6937;
  unsigned int D.6938;
  unsigned int D.6939;
  unsigned int D.6940;
  unsigned int D.6941;
  unsigned int D.6942;
  struct malloc_chunk * D.6943;
  unsigned int D.6944;
  unsigned int D.6945;

  if (alignment <= 8) goto <D.6849>; else goto <D.6850>;
  <D.6849>:
  D.6851 = dlmalloc (bytes);
  return D.6851;
  <D.6850>:
  if (alignment <= 15) goto <D.6852>; else goto <D.6853>;
  <D.6852>:
  alignment = 16;
  <D.6853>:
  D.6854 = alignment + 4294967295;
  D.6855 = D.6854 & alignment;
  if (D.6855 != 0) goto <D.6856>; else goto <D.6857>;
  <D.6856>:
  {
    size_t a;

    a = 16;
    goto <D.5110>;
    <D.5109>:
    a = a << 1;
    <D.5110>:
    if (a < alignment) goto <D.5109>; else goto <D.5111>;
    <D.5111>:
    alignment = a;
  }
  <D.6857>:
  D.6858 = 4294967232 - alignment;
  if (D.6858 <= bytes) goto <D.6859>; else goto <D.6860>;
  <D.6859>:
  if (m != 0B) goto <D.6861>; else goto <D.6862>;
  <D.6861>:
  D.6863 = __errno_location ();
  *D.6863 = 12;
  <D.6862>:
  goto <D.6864>;
  <D.6860>:
  {
    size_t nb;
    size_t req;
    char * mem;

    if (bytes > 10) goto <D.6866>; else goto <D.6867>;
    <D.6866>:
    D.6868 = bytes + 11;
    iftmp.50 = D.6868 & 4294967288;
    goto <D.6869>;
    <D.6867>:
    iftmp.50 = 16;
    <D.6869>:
    nb = iftmp.50;
    D.6870 = nb + alignment;
    req = D.6870 + 12;
    mem = dlmalloc (req);
    if (mem != 0B) goto <D.6871>; else goto <D.6872>;
    <D.6871>:
    {
      void * leader;
      void * trailer;
      struct malloc_chunk * p;

      leader = 0B;
      trailer = 0B;
      p = mem + 4294967288;
      D.6876 = mparams.page_size;
      if (D.6876 == 0) goto <D.6877>; else goto <D.6873>;
      <D.6877>:
      D.6878 = init_mparams ();
      if (D.6878 != 0) goto <D.6874>; else goto <D.6873>;
      <D.6873>:
      D.6879 = m->mflags;
      D.6880 = D.6879 & 2;
      if (D.6880 != 0) goto <D.6874>; else goto <D.6875>;
      <D.6874>:
      D.6881 = &m->mutex;
      D.6882 = pthread_mutex_lock (D.6881);
      if (D.6882 != 0) goto <D.6883>; else goto <D.6884>;
      <D.6883>:
      D.6851 = 0B;
      return D.6851;
      <D.6884>:
      <D.6875>:
      mem.51 = (unsigned int) mem;
      D.6886 = mem.51 % alignment;
      if (D.6886 != 0) goto <D.6887>; else goto <D.6888>;
      <D.6887>:
      {
        char * br;
        char * pos;
        struct malloc_chunk * newp;
        size_t leadsize;
        size_t newsize;

        D.6889 = alignment + 4294967295;
        D.6890 = mem + D.6889;
        D.6891 = (unsigned int) D.6890;
        D.6892 = -alignment;
        D.6893 = D.6891 & D.6892;
        D.6894 = D.6893 + 4294967288;
        br = (char *) D.6894;
        br.53 = (int) br;
        p.54 = (int) p;
        D.6898 = br.53 - p.54;
        D.6899 = (unsigned int) D.6898;
        if (D.6899 <= 15) goto <D.6900>; else goto <D.6901>;
        <D.6900>:
        iftmp.52 = br + alignment;
        goto <D.6902>;
        <D.6901>:
        iftmp.52 = br;
        <D.6902>:
        pos = iftmp.52;
        newp = pos;
        pos.55 = (int) pos;
        p.54 = (int) p;
        D.6904 = pos.55 - p.54;
        leadsize = (size_t) D.6904;
        D.6905 = p->head;
        D.6906 = D.6905 & 4294967292;
        newsize = D.6906 - leadsize;
        D.6905 = p->head;
        D.6909 = D.6905 & 1;
        if (D.6909 == 0) goto <D.6910>; else goto <D.6907>;
        <D.6910>:
        D.6911 = p->prev_foot;
        D.6912 = D.6911 & 1;
        if (D.6912 != 0) goto <D.6913>; else goto <D.6907>;
        <D.6913>:
        D.6911 = p->prev_foot;
        D.6914 = D.6911 + leadsize;
        newp->prev_foot = D.6914;
        D.6915 = newsize | 2;
        newp->head = D.6915;
        goto <D.6908>;
        <D.6907>:
        D.6916 = newp->head;
        D.6917 = D.6916 & 1;
        D.6918 = D.6917 | newsize;
        D.6919 = D.6918 | 2;
        newp->head = D.6919;
        D.6920 = newp + newsize;
        D.6920 = newp + newsize;
        D.6921 = D.6920->head;
        D.6922 = D.6921 | 1;
        D.6920->head = D.6922;
        D.6905 = p->head;
        D.6909 = D.6905 & 1;
        D.6923 = D.6909 | leadsize;
        D.6924 = D.6923 | 2;
        p->head = D.6924;
        D.6925 = p + leadsize;
        D.6925 = p + leadsize;
        D.6926 = D.6925->head;
        D.6927 = D.6926 | 1;
        D.6925->head = D.6927;
        leader = p + 8;
        <D.6908>:
        p = newp;
      }
      <D.6888>:
      D.6905 = p->head;
      D.6909 = D.6905 & 1;
      if (D.6909 != 0) goto <D.6928>; else goto <D.6930>;
      <D.6930>:
      D.6911 = p->prev_foot;
      D.6912 = D.6911 & 1;
      if (D.6912 == 0) goto <D.6928>; else goto <D.6929>;
      <D.6928>:
      {
        size_t size;

        D.6905 = p->head;
        size = D.6905 & 4294967292;
        D.6931 = nb + 16;
        if (D.6931 < size) goto <D.6932>; else goto <D.6933>;
        <D.6932>:
        {
          size_t remainder_size;
          struct malloc_chunk * remainder;

          remainder_size = size - nb;
          remainder = p + nb;
          D.6905 = p->head;
          D.6909 = D.6905 & 1;
          D.6934 = D.6909 | nb;
          D.6935 = D.6934 | 2;
          p->head = D.6935;
          D.6936 = p + nb;
          D.6936 = p + nb;
          D.6937 = D.6936->head;
          D.6938 = D.6937 | 1;
          D.6936->head = D.6938;
          D.6939 = remainder->head;
          D.6940 = D.6939 & 1;
          D.6941 = D.6940 | remainder_size;
          D.6942 = D.6941 | 2;
          remainder->head = D.6942;
          D.6943 = remainder + remainder_size;
          D.6943 = remainder + remainder_size;
          D.6944 = D.6943->head;
          D.6945 = D.6944 | 1;
          D.6943->head = D.6945;
          trailer = remainder + 8;
        }
        <D.6933>:
      }
      <D.6929>:
      D.6879 = m->mflags;
      D.6880 = D.6879 & 2;
      if (D.6880 != 0) goto <D.6946>; else goto <D.6947>;
      <D.6946>:
      D.6881 = &m->mutex;
      pthread_mutex_unlock (D.6881);
      <D.6947>:
      if (leader != 0B) goto <D.6948>; else goto <D.6949>;
      <D.6948>:
      dlfree (leader);
      <D.6949>:
      if (trailer != 0B) goto <D.6950>; else goto <D.6951>;
      <D.6950>:
      dlfree (trailer);
      <D.6951>:
      D.6851 = p + 8;
      return D.6851;
    }
    <D.6872>:
  }
  <D.6864>:
  D.6851 = 0B;
  return D.6851;
}