dlmalloc (size_t bytes)
{
  long unsigned int D.6130;
  int D.6132;
  unsigned int D.6133;
  unsigned int D.6134;
  int D.6135;
  long unsigned int iftmp.0;
  long unsigned int D.6141;
  long unsigned int D.6143;
  unsigned int D.6144;
  int idx.1;
  unsigned int D.6146;
  unsigned int D.6149;
  _Bool D.6150;
  unsigned int D.6151;
  unsigned int D.6152;
  unsigned int D.6155;
  unsigned int D.6156;
  unsigned int D.6157;
  char * D.6159;
  _Bool D.6160;
  long int D.6161;
  long int D.6162;
  unsigned int D.6166;
  unsigned int D.6167;
  long unsigned int D.6168;
  sizetype D.6169;
  struct malloc_chunk * D.6170;
  long unsigned int D.6171;
  long unsigned int D.6172;
  long unsigned int D.6173;
  unsigned int D.6178;
  unsigned int D.6179;
  unsigned int D.6180;
  unsigned int D.6181;
  unsigned int D.6182;
  unsigned int D.6183;
  int K.2;
  unsigned int D.6185;
  unsigned int K.3;
  unsigned int D.6187;
  unsigned int K.4;
  unsigned int D.6189;
  unsigned int K.5;
  unsigned int K.6;
  unsigned int D.6192;
  int i.7;
  unsigned int D.6196;
  unsigned int D.6197;
  unsigned int D.6198;
  _Bool D.6200;
  long int D.6201;
  long int D.6202;
  unsigned int D.6206;
  long unsigned int D.6207;
  unsigned int D.6210;
  long unsigned int D.6211;
  sizetype D.6212;
  struct malloc_chunk * D.6213;
  long unsigned int D.6214;
  long unsigned int D.6215;
  long unsigned int D.6217;
  long unsigned int D.6218;
  struct malloc_chunk * D.6219;
  long unsigned int D.6222;
  unsigned int D.6223;
  int I.8;
  unsigned int D.6225;
  unsigned int D.6226;
  unsigned int D.6229;
  struct malloc_chunk * D.6231;
  _Bool D.6232;
  long int D.6233;
  long int D.6234;
  unsigned int D.6238;
  struct malloc_chunk * D.6253;
  long unsigned int D.6254;
  struct malloc_chunk * D.6255;
  long unsigned int D.6257;
  struct malloc_chunk * D.6258;
  long unsigned int D.6259;
  long unsigned int D.6260;
  long unsigned int D.6261;
  long unsigned int D.6264;
  struct malloc_chunk * D.6265;
  long unsigned int D.6266;
  void * D.6269;
  void postaction = <<< error >>>;

  D.6130 = mparams.page_size;
  if (D.6130 != 0) goto <D.6126>; else goto <D.6131>;
  <D.6131>:
  D.6132 = init_mparams ();
  if (D.6132 == 0) goto <D.6126>; else goto <D.6127>;
  <D.6126>:
  D.6133 = _gm_.mflags;
  D.6134 = D.6133 & 2;
  if (D.6134 == 0) goto <D.6128>; else goto <D.6127>;
  <D.6127>:
  D.6135 = pthread_mutex_lock (&_gm_.mutex);
  if (D.6135 == 0) goto <D.6128>; else goto <D.6129>;
  <D.6128>:
  {
    void * mem;
    size_t nb;

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

      if (bytes > 22) goto <D.6139>; else goto <D.6140>;
      <D.6139>:
      D.6141 = bytes + 15;
      iftmp.0 = D.6141 & 18446744073709551608;
      goto <D.6142>;
      <D.6140>:
      iftmp.0 = 32;
      <D.6142>:
      nb = iftmp.0;
      D.6143 = nb >> 3;
      idx = (bindex_t) D.6143;
      D.6144 = _gm_.smallmap;
      idx.1 = (int) idx;
      smallbits = D.6144 >> idx.1;
      D.6146 = smallbits & 3;
      if (D.6146 != 0) goto <D.6147>; else goto <D.6148>;
      <D.6147>:
      {
        struct malloc_chunk * b;
        struct malloc_chunk * p;

        D.6149 = smallbits & 1;
        D.6150 = D.6149 == 0;
        D.6151 = (unsigned int) D.6150;
        idx = D.6151 + idx;
        D.6152 = idx << 1;
        b = &_gm_.smallbins[D.6152];
        p = b->fd;
        {
          struct malloc_chunk * F;

          F = p->fd;
          if (b == F) goto <D.6153>; else goto <D.6154>;
          <D.6153>:
          D.6144 = _gm_.smallmap;
          idx.1 = (int) idx;
          D.6155 = 1 << idx.1;
          D.6156 = ~D.6155;
          D.6157 = D.6144 & D.6156;
          _gm_.smallmap = D.6157;
          goto <D.6158>;
          <D.6154>:
          D.6159 = _gm_.least_addr;
          D.6160 = D.6159 <= F;
          D.6161 = (long int) D.6160;
          D.6162 = __builtin_expect (D.6161, 1);
          if (D.6162 != 0) goto <D.6163>; else goto <D.6164>;
          <D.6163>:
          b->fd = F;
          F->bk = b;
          goto <D.6165>;
          <D.6164>:
          abort ();
          <D.6165>:
          <D.6158>:
        }
        D.6166 = idx << 3;
        D.6167 = D.6166 | 3;
        D.6168 = (long unsigned int) D.6167;
        p->head = D.6168;
        D.6166 = idx << 3;
        D.6169 = (sizetype) D.6166;
        D.6170 = p + D.6169;
        D.6166 = idx << 3;
        D.6169 = (sizetype) D.6166;
        D.6170 = p + D.6169;
        D.6171 = D.6170->head;
        D.6172 = D.6171 | 1;
        D.6170->head = D.6172;
        mem = p + 16;
        goto postaction;
      }
      <D.6148>:
      D.6173 = _gm_.dvsize;
      if (D.6173 < nb) goto <D.6174>; else goto <D.6175>;
      <D.6174>:
      if (smallbits != 0) goto <D.6176>; else goto <D.6177>;
      <D.6176>:
      {
        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.6178 = smallbits << idx.1;
        idx.1 = (int) idx;
        D.6155 = 1 << idx.1;
        D.6179 = D.6155 << 1;
        idx.1 = (int) idx;
        D.6155 = 1 << idx.1;
        D.6179 = D.6155 << 1;
        D.6180 = -D.6179;
        D.6181 = D.6179 | D.6180;
        leftbits = D.6178 & D.6181;
        D.6182 = -leftbits;
        leastbit = D.6182 & leftbits;
        {
          unsigned int Y;
          unsigned int K;
          unsigned int N;

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

          F = p->fd;
          if (b == F) goto <D.6193>; else goto <D.6194>;
          <D.6193>:
          D.6144 = _gm_.smallmap;
          i.7 = (int) i;
          D.6196 = 1 << i.7;
          D.6197 = ~D.6196;
          D.6198 = D.6144 & D.6197;
          _gm_.smallmap = D.6198;
          goto <D.6199>;
          <D.6194>:
          D.6159 = _gm_.least_addr;
          D.6200 = D.6159 <= F;
          D.6201 = (long int) D.6200;
          D.6202 = __builtin_expect (D.6201, 1);
          if (D.6202 != 0) goto <D.6203>; else goto <D.6204>;
          <D.6203>:
          b->fd = F;
          F->bk = b;
          goto <D.6205>;
          <D.6204>:
          abort ();
          <D.6205>:
          <D.6199>:
        }
        D.6206 = i << 3;
        D.6207 = (long unsigned int) D.6206;
        rsize = D.6207 - nb;
        if (rsize <= 31) goto <D.6208>; else goto <D.6209>;
        <D.6208>:
        D.6206 = i << 3;
        D.6210 = D.6206 | 3;
        D.6211 = (long unsigned int) D.6210;
        p->head = D.6211;
        D.6206 = i << 3;
        D.6212 = (sizetype) D.6206;
        D.6213 = p + D.6212;
        D.6206 = i << 3;
        D.6212 = (sizetype) D.6206;
        D.6213 = p + D.6212;
        D.6214 = D.6213->head;
        D.6215 = D.6214 | 1;
        D.6213->head = D.6215;
        goto <D.6216>;
        <D.6209>:
        D.6217 = nb | 3;
        p->head = D.6217;
        r = p + nb;
        D.6218 = rsize | 1;
        r->head = D.6218;
        D.6219 = r + rsize;
        D.6219->prev_foot = rsize;
        {
          size_t DVS;

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

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

              D.6222 = DVS >> 3;
              I = (bindex_t) D.6222;
              D.6223 = I << 1;
              B = &_gm_.smallbins[D.6223];
              F = B;
              D.6144 = _gm_.smallmap;
              I.8 = (int) I;
              D.6225 = 1 << I.8;
              D.6226 = D.6144 & D.6225;
              if (D.6226 == 0) goto <D.6227>; else goto <D.6228>;
              <D.6227>:
              D.6144 = _gm_.smallmap;
              I.8 = (int) I;
              D.6225 = 1 << I.8;
              D.6229 = D.6144 | D.6225;
              _gm_.smallmap = D.6229;
              goto <D.6230>;
              <D.6228>:
              D.6231 = B->fd;
              D.6159 = _gm_.least_addr;
              D.6232 = D.6231 >= D.6159;
              D.6233 = (long int) D.6232;
              D.6234 = __builtin_expect (D.6233, 1);
              if (D.6234 != 0) goto <D.6235>; else goto <D.6236>;
              <D.6235>:
              F = B->fd;
              goto <D.6237>;
              <D.6236>:
              abort ();
              <D.6237>:
              <D.6230>:
              B->fd = DV;
              F->bk = DV;
              DV->fd = F;
              DV->bk = B;
            }
          }
          <D.6221>:
          _gm_.dvsize = rsize;
          _gm_.dv = r;
        }
        <D.6216>:
        mem = p + 16;
        goto postaction;
      }
      <D.6177>:
      D.6238 = _gm_.treemap;
      if (D.6238 != 0) goto <D.6239>; else goto <D.6240>;
      <D.6239>:
      mem = tmalloc_small (&_gm_, nb);
      if (mem != 0B) goto postaction; else goto <D.6241>;
      <D.6241>:
      <D.6240>:
      <D.6175>:
    }
    goto <D.6242>;
    <D.6137>:
    if (bytes > 18446744073709551487) goto <D.6243>; else goto <D.6244>;
    <D.6243>:
    nb = 18446744073709551615;
    goto <D.6245>;
    <D.6244>:
    D.6141 = bytes + 15;
    nb = D.6141 & 18446744073709551608;
    D.6238 = _gm_.treemap;
    if (D.6238 != 0) goto <D.6246>; else goto <D.6247>;
    <D.6246>:
    mem = tmalloc_large (&_gm_, nb);
    if (mem != 0B) goto postaction; else goto <D.6248>;
    <D.6248>:
    <D.6247>:
    <D.6245>:
    <D.6242>:
    D.6173 = _gm_.dvsize;
    if (D.6173 >= nb) goto <D.6249>; else goto <D.6250>;
    <D.6249>:
    {
      size_t rsize;
      struct malloc_chunk * p;

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

        D.6253 = p + nb;
        _gm_.dv = D.6253;
        r = _gm_.dv;
        _gm_.dvsize = rsize;
        D.6254 = rsize | 1;
        r->head = D.6254;
        D.6255 = r + rsize;
        D.6255->prev_foot = rsize;
        D.6217 = nb | 3;
        p->head = D.6217;
      }
      goto <D.6256>;
      <D.6252>:
      {
        size_t dvs;

        dvs = _gm_.dvsize;
        _gm_.dvsize = 0;
        _gm_.dv = 0B;
        D.6257 = dvs | 3;
        p->head = D.6257;
        D.6258 = p + dvs;
        D.6258 = p + dvs;
        D.6259 = D.6258->head;
        D.6260 = D.6259 | 1;
        D.6258->head = D.6260;
      }
      <D.6256>:
      mem = p + 16;
      goto postaction;
    }
    <D.6250>:
    D.6261 = _gm_.topsize;
    if (D.6261 > nb) goto <D.6262>; else goto <D.6263>;
    <D.6262>:
    {
      size_t rsize;
      struct malloc_chunk * p;
      struct malloc_chunk * r;

      D.6261 = _gm_.topsize;
      D.6264 = D.6261 - nb;
      _gm_.topsize = D.6264;
      rsize = _gm_.topsize;
      p = _gm_.top;
      D.6265 = p + nb;
      _gm_.top = D.6265;
      r = _gm_.top;
      D.6266 = rsize | 1;
      r->head = D.6266;
      D.6217 = nb | 3;
      p->head = D.6217;
      mem = p + 16;
      goto postaction;
    }
    <D.6263>:
    mem = sys_alloc (&_gm_, nb);
    postaction:
    D.6133 = _gm_.mflags;
    D.6134 = D.6133 & 2;
    if (D.6134 != 0) goto <D.6267>; else goto <D.6268>;
    <D.6267>:
    pthread_mutex_unlock (&_gm_.mutex);
    <D.6268>:
    D.6269 = mem;
    return D.6269;
  }
  <D.6129>:
  D.6269 = 0B;
  return D.6269;
}


init_mparams ()
{
  long unsigned int D.6271;
  long unsigned int D.6274;
  unsigned int D.6277;
  long unsigned int D.6280;
  long unsigned int D.6281;
  long unsigned int D.6282;
  long unsigned int D.6284;
  long unsigned int D.6285;
  int D.6286;

  D.6271 = mparams.page_size;
  if (D.6271 == 0) goto <D.6272>; else goto <D.6273>;
  <D.6272>:
  {
    size_t s;

    mparams.mmap_threshold = 262144;
    mparams.trim_threshold = 2097152;
    mparams.default_mflags = 7;
    s = 1482184792;
    pthread_mutex_lock (&magic_init_mutex);
    D.6274 = mparams.magic;
    if (D.6274 == 0) goto <D.6275>; else goto <D.6276>;
    <D.6275>:
    mparams.magic = s;
    pthread_mutex_init (&_gm_.mutex, 0B);
    D.6277 = mparams.default_mflags;
    _gm_.mflags = D.6277;
    <D.6276>:
    pthread_mutex_unlock (&magic_init_mutex);
    mparams.page_size = 4096;
    mparams.granularity = 65536;
    D.6280 = mparams.granularity;
    D.6280 = mparams.granularity;
    D.6281 = D.6280 + 18446744073709551615;
    D.6282 = D.6280 & D.6281;
    if (D.6282 != 0) goto <D.6278>; else goto <D.6283>;
    <D.6283>:
    D.6271 = mparams.page_size;
    D.6271 = mparams.page_size;
    D.6284 = D.6271 + 18446744073709551615;
    D.6285 = D.6271 & D.6284;
    if (D.6285 != 0) goto <D.6278>; else goto <D.6279>;
    <D.6278>:
    abort ();
    <D.6279>:
  }
  <D.6273>:
  D.6286 = 0;
  return D.6286;
}


tmalloc_small (struct malloc_state * m, size_t nb)
{
  unsigned int D.6288;
  unsigned int D.6289;
  unsigned int D.6290;
  int K.9;
  unsigned int D.6292;
  unsigned int K.10;
  unsigned int D.6294;
  unsigned int K.11;
  unsigned int D.6296;
  unsigned int K.12;
  unsigned int K.13;
  long unsigned int D.6299;
  long unsigned int D.6300;
  struct malloc_tree_chunk * iftmp.14;
  struct malloc_tree_chunk * D.6304;
  char * D.6308;
  _Bool D.6309;
  long int D.6310;
  long int D.6311;
  _Bool D.6314;
  long int D.6315;
  long int D.6316;
  struct malloc_tree_chunk * D.6319;
  _Bool D.6322;
  long int D.6323;
  long int D.6324;
  struct malloc_tree_chunk * D.6332;
  _Bool D.6334;
  long int D.6335;
  long int D.6336;
  unsigned int D.6342;
  struct malloc_tree_chunk * D.6343;
  int D.6348;
  unsigned int D.6349;
  unsigned int D.6350;
  unsigned int D.6351;
  _Bool D.6353;
  long int D.6354;
  long int D.6355;
  struct malloc_tree_chunk * D.6358;
  _Bool D.6365;
  long int D.6366;
  long int D.6367;
  _Bool D.6372;
  long int D.6373;
  long int D.6374;
  _Bool D.6380;
  long int D.6381;
  long int D.6382;
  long unsigned int D.6389;
  long unsigned int D.6390;
  struct malloc_chunk * D.6391;
  long unsigned int D.6392;
  long unsigned int D.6393;
  long unsigned int D.6395;
  long unsigned int D.6396;
  struct malloc_chunk * D.6397;
  long unsigned int D.6400;
  unsigned int D.6401;
  unsigned int D.6402;
  int I.15;
  unsigned int D.6404;
  unsigned int D.6405;
  unsigned int D.6408;
  struct malloc_chunk * D.6410;
  _Bool D.6411;
  long int D.6412;
  long int D.6413;
  void * D.6417;
  struct malloc_tree_chunk * t;
  struct malloc_tree_chunk * v;
  size_t rsize;
  bindex_t i;
  binmap_t leastbit;

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

    Y = leastbit + 4294967295;
    D.6290 = Y >> 12;
    K = D.6290 & 16;
    N = K;
    K.9 = (int) K;
    Y = Y >> K.9;
    D.6292 = Y >> 5;
    K = D.6292 & 8;
    K.10 = K;
    N = K.10 + N;
    K.9 = (int) K;
    Y = Y >> K.9;
    D.6294 = Y >> 2;
    K = D.6294 & 4;
    K.11 = K;
    N = K.11 + N;
    K.9 = (int) K;
    Y = Y >> K.9;
    D.6296 = Y >> 1;
    K = D.6296 & 2;
    K.12 = K;
    N = K.12 + N;
    K.9 = (int) K;
    Y = Y >> K.9;
    D.6296 = Y >> 1;
    K = D.6296 & 1;
    K.13 = K;
    N = K.13 + N;
    K.9 = (int) K;
    Y = Y >> K.9;
    i = N + Y;
  }
  t = m->treebins[i];
  v = t;
  D.6299 = t->head;
  D.6300 = D.6299 & 18446744073709551612;
  rsize = D.6300 - nb;
  goto <D.5986>;
  <D.5985>:
  {
    size_t trem;

    D.6299 = t->head;
    D.6300 = D.6299 & 18446744073709551612;
    trem = D.6300 - nb;
    if (trem < rsize) goto <D.6301>; else goto <D.6302>;
    <D.6301>:
    rsize = trem;
    v = t;
    <D.6302>:
  }
  <D.5986>:
  D.6304 = t->child[0];
  if (D.6304 != 0B) goto <D.6305>; else goto <D.6306>;
  <D.6305>:
  iftmp.14 = t->child[0];
  goto <D.6307>;
  <D.6306>:
  iftmp.14 = t->child[1];
  <D.6307>:
  t = iftmp.14;
  if (t != 0B) goto <D.5985>; else goto <D.5987>;
  <D.5987>:
  D.6308 = m->least_addr;
  D.6309 = D.6308 <= v;
  D.6310 = (long int) D.6309;
  D.6311 = __builtin_expect (D.6310, 1);
  if (D.6311 != 0) goto <D.6312>; else goto <D.6313>;
  <D.6312>:
  {
    struct malloc_chunk * r;

    r = v + nb;
    D.6314 = v < r;
    D.6315 = (long int) D.6314;
    D.6316 = __builtin_expect (D.6315, 1);
    if (D.6316 != 0) goto <D.6317>; else goto <D.6318>;
    <D.6317>:
    {
      struct malloc_tree_chunk * XP;
      struct malloc_tree_chunk * R;

      XP = v->parent;
      D.6319 = v->bk;
      if (D.6319 != v) goto <D.6320>; else goto <D.6321>;
      <D.6320>:
      {
        struct malloc_tree_chunk * F;

        F = v->fd;
        R = v->bk;
        D.6308 = m->least_addr;
        D.6322 = D.6308 <= F;
        D.6323 = (long int) D.6322;
        D.6324 = __builtin_expect (D.6323, 1);
        if (D.6324 != 0) goto <D.6325>; else goto <D.6326>;
        <D.6325>:
        F->bk = R;
        R->fd = F;
        goto <D.6327>;
        <D.6326>:
        abort ();
        <D.6327>:
      }
      goto <D.6328>;
      <D.6321>:
      {
        struct malloc_tree_chunk * * RP;

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

          goto <D.5995>;
          <D.5994>:
          RP = CP;
          R = *RP;
          <D.5995>:
          CP = &R->child[1];
          D.6332 = *CP;
          if (D.6332 != 0B) goto <D.5994>; else goto <D.6333>;
          <D.6333>:
          CP = &R->child[0];
          D.6332 = *CP;
          if (D.6332 != 0B) goto <D.5994>; else goto <D.5996>;
          <D.5996>:
          D.6308 = m->least_addr;
          D.6334 = D.6308 <= RP;
          D.6335 = (long int) D.6334;
          D.6336 = __builtin_expect (D.6335, 1);
          if (D.6336 != 0) goto <D.6337>; else goto <D.6338>;
          <D.6337>:
          *RP = 0B;
          goto <D.6339>;
          <D.6338>:
          abort ();
          <D.6339>:
        }
        <D.6330>:
      }
      <D.6328>:
      if (XP != 0B) goto <D.6340>; else goto <D.6341>;
      <D.6340>:
      {
        struct malloc_tree_chunk * * H;

        D.6342 = v->index;
        H = &m->treebins[D.6342];
        D.6343 = *H;
        if (D.6343 == v) goto <D.6344>; else goto <D.6345>;
        <D.6344>:
        *H = R;
        D.6343 = *H;
        if (D.6343 == 0B) goto <D.6346>; else goto <D.6347>;
        <D.6346>:
        D.6288 = m->treemap;
        D.6342 = v->index;
        D.6348 = (int) D.6342;
        D.6349 = 1 << D.6348;
        D.6350 = ~D.6349;
        D.6351 = D.6288 & D.6350;
        m->treemap = D.6351;
        <D.6347>:
        goto <D.6352>;
        <D.6345>:
        D.6308 = m->least_addr;
        D.6353 = D.6308 <= XP;
        D.6354 = (long int) D.6353;
        D.6355 = __builtin_expect (D.6354, 1);
        if (D.6355 != 0) goto <D.6356>; else goto <D.6357>;
        <D.6356>:
        D.6358 = XP->child[0];
        if (D.6358 == v) goto <D.6359>; else goto <D.6360>;
        <D.6359>:
        XP->child[0] = R;
        goto <D.6361>;
        <D.6360>:
        XP->child[1] = R;
        <D.6361>:
        goto <D.6362>;
        <D.6357>:
        abort ();
        <D.6362>:
        <D.6352>:
        if (R != 0B) goto <D.6363>; else goto <D.6364>;
        <D.6363>:
        D.6308 = m->least_addr;
        D.6365 = D.6308 <= R;
        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>:
        {
          struct malloc_tree_chunk * C0;
          struct malloc_tree_chunk * C1;

          R->parent = XP;
          C0 = v->child[0];
          if (C0 != 0B) goto <D.6370>; else goto <D.6371>;
          <D.6370>:
          D.6308 = m->least_addr;
          D.6372 = D.6308 <= C0;
          D.6373 = (long int) D.6372;
          D.6374 = __builtin_expect (D.6373, 1);
          if (D.6374 != 0) goto <D.6375>; else goto <D.6376>;
          <D.6375>:
          R->child[0] = C0;
          C0->parent = R;
          goto <D.6377>;
          <D.6376>:
          abort ();
          <D.6377>:
          <D.6371>:
          C1 = v->child[1];
          if (C1 != 0B) goto <D.6378>; else goto <D.6379>;
          <D.6378>:
          D.6308 = m->least_addr;
          D.6380 = D.6308 <= C1;
          D.6381 = (long int) D.6380;
          D.6382 = __builtin_expect (D.6381, 1);
          if (D.6382 != 0) goto <D.6383>; else goto <D.6384>;
          <D.6383>:
          R->child[1] = C1;
          C1->parent = R;
          goto <D.6385>;
          <D.6384>:
          abort ();
          <D.6385>:
          <D.6379>:
        }
        goto <D.6386>;
        <D.6369>:
        abort ();
        <D.6386>:
        <D.6364>:
      }
      <D.6341>:
    }
    if (rsize <= 31) goto <D.6387>; else goto <D.6388>;
    <D.6387>:
    D.6389 = rsize + nb;
    D.6390 = D.6389 | 3;
    v->head = D.6390;
    D.6389 = rsize + nb;
    D.6391 = v + D.6389;
    D.6389 = rsize + nb;
    D.6391 = v + D.6389;
    D.6392 = D.6391->head;
    D.6393 = D.6392 | 1;
    D.6391->head = D.6393;
    goto <D.6394>;
    <D.6388>:
    D.6395 = nb | 3;
    v->head = D.6395;
    D.6396 = rsize | 1;
    r->head = D.6396;
    D.6397 = r + rsize;
    D.6397->prev_foot = rsize;
    {
      size_t DVS;

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

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

          D.6400 = DVS >> 3;
          I = (bindex_t) D.6400;
          D.6401 = I << 1;
          B = &m->smallbins[D.6401];
          F = B;
          D.6402 = m->smallmap;
          I.15 = (int) I;
          D.6404 = 1 << I.15;
          D.6405 = D.6402 & D.6404;
          if (D.6405 == 0) goto <D.6406>; else goto <D.6407>;
          <D.6406>:
          D.6402 = m->smallmap;
          I.15 = (int) I;
          D.6404 = 1 << I.15;
          D.6408 = D.6402 | D.6404;
          m->smallmap = D.6408;
          goto <D.6409>;
          <D.6407>:
          D.6410 = B->fd;
          D.6308 = m->least_addr;
          D.6411 = D.6410 >= D.6308;
          D.6412 = (long int) D.6411;
          D.6413 = __builtin_expect (D.6412, 1);
          if (D.6413 != 0) goto <D.6414>; else goto <D.6415>;
          <D.6414>:
          F = B->fd;
          goto <D.6416>;
          <D.6415>:
          abort ();
          <D.6416>:
          <D.6409>:
          B->fd = DV;
          F->bk = DV;
          DV->fd = F;
          DV->bk = B;
        }
      }
      <D.6399>:
      m->dvsize = rsize;
      m->dv = r;
    }
    <D.6394>:
    D.6417 = v + 16;
    return D.6417;
    <D.6318>:
  }
  <D.6313>:
  abort ();
  D.6417 = 0B;
  return D.6417;
}


tmalloc_large (struct malloc_state * m, size_t nb)
{
  unsigned int D.6425;
  unsigned int D.6426;
  int N.16;
  unsigned int D.6428;
  unsigned int D.6429;
  int K.17;
  unsigned int D.6431;
  unsigned int D.6432;
  unsigned int K.18;
  unsigned int D.6434;
  unsigned int D.6435;
  unsigned int D.6436;
  unsigned int D.6437;
  int D.6438;
  long unsigned int D.6439;
  unsigned int D.6440;
  unsigned int D.6441;
  int iftmp.19;
  unsigned int D.6447;
  unsigned int D.6448;
  long unsigned int D.6449;
  long unsigned int D.6450;
  long unsigned int D.6452;
  long unsigned int D.6453;
  long unsigned int D.6457;
  int idx.20;
  unsigned int D.6469;
  unsigned int D.6470;
  unsigned int D.6471;
  unsigned int D.6472;
  unsigned int D.6473;
  unsigned int D.6476;
  unsigned int D.6477;
  int K.21;
  unsigned int D.6479;
  unsigned int K.22;
  unsigned int D.6481;
  unsigned int K.23;
  unsigned int D.6483;
  unsigned int K.24;
  unsigned int K.25;
  struct malloc_tree_chunk * iftmp.26;
  struct malloc_tree_chunk * D.6489;
  long unsigned int D.6495;
  long unsigned int D.6496;
  char * D.6499;
  _Bool D.6500;
  long int D.6501;
  long int D.6502;
  _Bool D.6505;
  long int D.6506;
  long int D.6507;
  struct malloc_tree_chunk * D.6510;
  _Bool D.6513;
  long int D.6514;
  long int D.6515;
  struct malloc_tree_chunk * D.6523;
  _Bool D.6525;
  long int D.6526;
  long int D.6527;
  unsigned int D.6533;
  struct malloc_tree_chunk * D.6534;
  int D.6539;
  unsigned int D.6540;
  unsigned int D.6541;
  unsigned int D.6542;
  _Bool D.6544;
  long int D.6545;
  long int D.6546;
  struct malloc_tree_chunk * D.6549;
  _Bool D.6556;
  long int D.6557;
  long int D.6558;
  _Bool D.6563;
  long int D.6564;
  long int D.6565;
  _Bool D.6571;
  long int D.6572;
  long int D.6573;
  long unsigned int D.6580;
  long unsigned int D.6581;
  struct malloc_chunk * D.6582;
  long unsigned int D.6583;
  long unsigned int D.6584;
  long unsigned int D.6586;
  long unsigned int D.6587;
  struct malloc_chunk * D.6588;
  long unsigned int D.6589;
  unsigned int D.6592;
  unsigned int D.6593;
  int I.27;
  unsigned int D.6595;
  unsigned int D.6596;
  unsigned int D.6599;
  struct malloc_chunk * D.6601;
  _Bool D.6602;
  long int D.6603;
  long int D.6604;
  unsigned int D.6615;
  unsigned int D.6616;
  int N.28;
  unsigned int D.6618;
  unsigned int D.6619;
  int K.29;
  unsigned int D.6621;
  unsigned int D.6622;
  unsigned int K.30;
  unsigned int D.6624;
  unsigned int D.6625;
  unsigned int D.6626;
  unsigned int D.6627;
  int D.6628;
  long unsigned int D.6629;
  unsigned int D.6630;
  unsigned int D.6631;
  struct malloc_tree_chunk * D.6632;
  int I.31;
  unsigned int D.6634;
  unsigned int D.6635;
  unsigned int D.6638;
  struct malloc_tree_chunk * D.6639;
  int iftmp.32;
  unsigned int D.6644;
  unsigned int D.6645;
  long unsigned int D.6646;
  long unsigned int D.6647;
  long unsigned int D.6649;
  long unsigned int D.6650;
  long unsigned int D.6653;
  struct malloc_tree_chunk * D.6654;
  _Bool D.6658;
  long int D.6659;
  long int D.6660;
  _Bool D.6665;
  long int D.6666;
  long int D.6667;
  _Bool D.6669;
  long int D.6670;
  long int D.6671;
  struct malloc_tree_chunk * D.6673;
  void * D.6674;
  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.6419>; else goto <D.6420>;
    <D.6419>:
    idx = 0;
    goto <D.6421>;
    <D.6420>:
    if (X > 65535) goto <D.6422>; else goto <D.6423>;
    <D.6422>:
    idx = 31;
    goto <D.6424>;
    <D.6423>:
    {
      unsigned int Y;
      unsigned int N;
      unsigned int K;

      Y = (unsigned int) X;
      D.6425 = Y + 4294967040;
      D.6426 = D.6425 >> 16;
      N = D.6426 & 8;
      N.16 = (int) N;
      Y = Y << N.16;
      D.6428 = Y + 4294963200;
      D.6429 = D.6428 >> 16;
      K = D.6429 & 4;
      N = N + K;
      K.17 = (int) K;
      Y = Y << K.17;
      D.6431 = Y + 4294950912;
      D.6432 = D.6431 >> 16;
      K = D.6432 & 2;
      K.18 = K;
      N = K.18 + N;
      K.17 = (int) K;
      Y = Y << K.17;
      D.6434 = Y >> 15;
      D.6435 = D.6434 - N;
      K = D.6435 + 14;
      D.6436 = K << 1;
      D.6437 = K + 7;
      D.6438 = (int) D.6437;
      D.6439 = nb >> D.6438;
      D.6440 = (unsigned int) D.6439;
      D.6441 = D.6440 & 1;
      idx = D.6436 + D.6441;
    }
    <D.6424>:
    <D.6421>:
  }
  t = m->treebins[idx];
  if (t != 0B) goto <D.6442>; else goto <D.6443>;
  <D.6442>:
  {
    size_t sizebits;
    struct malloc_tree_chunk * rst;

    if (idx != 31) goto <D.6445>; else goto <D.6446>;
    <D.6445>:
    D.6447 = idx >> 1;
    D.6448 = D.6447 + 6;
    D.6449 = (long unsigned int) D.6448;
    D.6450 = 63 - D.6449;
    iftmp.19 = (int) D.6450;
    goto <D.6451>;
    <D.6446>:
    iftmp.19 = 0;
    <D.6451>:
    sizebits = nb << iftmp.19;
    rst = 0B;
    <D.5933>:
    {
      struct malloc_tree_chunk * rt;
      size_t trem;

      D.6452 = t->head;
      D.6453 = D.6452 & 18446744073709551612;
      trem = D.6453 - nb;
      if (trem < rsize) goto <D.6454>; else goto <D.6455>;
      <D.6454>:
      v = t;
      rsize = trem;
      if (rsize == 0) goto <D.5932>; else goto <D.6456>;
      <D.6456>:
      <D.6455>:
      rt = t->child[1];
      D.6457 = sizebits >> 63;
      t = t->child[D.6457];
      if (rt != 0B) goto <D.6458>; else goto <D.6459>;
      <D.6458>:
      if (rt != t) goto <D.6460>; else goto <D.6461>;
      <D.6460>:
      rst = rt;
      <D.6461>:
      <D.6459>:
      if (t == 0B) goto <D.6462>; else goto <D.6463>;
      <D.6462>:
      t = rst;
      goto <D.5932>;
      <D.6463>:
      sizebits = sizebits << 1;
    }
    goto <D.5933>;
    <D.5932>:
  }
  <D.6443>:
  if (t == 0B) goto <D.6464>; else goto <D.6465>;
  <D.6464>:
  if (v == 0B) goto <D.6466>; else goto <D.6467>;
  <D.6466>:
  {
    binmap_t leftbits;

    idx.20 = (int) idx;
    D.6469 = 1 << idx.20;
    D.6470 = D.6469 << 1;
    idx.20 = (int) idx;
    D.6469 = 1 << idx.20;
    D.6470 = D.6469 << 1;
    D.6471 = -D.6470;
    D.6472 = D.6470 | D.6471;
    D.6473 = m->treemap;
    leftbits = D.6472 & D.6473;
    if (leftbits != 0) goto <D.6474>; else goto <D.6475>;
    <D.6474>:
    {
      bindex_t i;
      binmap_t leastbit;

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

        Y = leastbit + 4294967295;
        D.6477 = Y >> 12;
        K = D.6477 & 16;
        N = K;
        K.21 = (int) K;
        Y = Y >> K.21;
        D.6479 = Y >> 5;
        K = D.6479 & 8;
        K.22 = K;
        N = K.22 + N;
        K.21 = (int) K;
        Y = Y >> K.21;
        D.6481 = Y >> 2;
        K = D.6481 & 4;
        K.23 = K;
        N = K.23 + N;
        K.21 = (int) K;
        Y = Y >> K.21;
        D.6483 = Y >> 1;
        K = D.6483 & 2;
        K.24 = K;
        N = K.24 + N;
        K.21 = (int) K;
        Y = Y >> K.21;
        D.6483 = Y >> 1;
        K = D.6483 & 1;
        K.25 = K;
        N = K.25 + N;
        K.21 = (int) K;
        Y = Y >> K.21;
        i = N + Y;
      }
      t = m->treebins[i];
    }
    <D.6475>:
  }
  <D.6467>:
  <D.6465>:
  goto <D.5942>;
  <D.5941>:
  {
    size_t trem;

    D.6452 = t->head;
    D.6453 = D.6452 & 18446744073709551612;
    trem = D.6453 - nb;
    if (trem < rsize) goto <D.6486>; else goto <D.6487>;
    <D.6486>:
    rsize = trem;
    v = t;
    <D.6487>:
    D.6489 = t->child[0];
    if (D.6489 != 0B) goto <D.6490>; else goto <D.6491>;
    <D.6490>:
    iftmp.26 = t->child[0];
    goto <D.6492>;
    <D.6491>:
    iftmp.26 = t->child[1];
    <D.6492>:
    t = iftmp.26;
  }
  <D.5942>:
  if (t != 0B) goto <D.5941>; else goto <D.5943>;
  <D.5943>:
  if (v != 0B) goto <D.6493>; else goto <D.6494>;
  <D.6493>:
  D.6495 = m->dvsize;
  D.6496 = D.6495 - nb;
  if (D.6496 > rsize) goto <D.6497>; else goto <D.6498>;
  <D.6497>:
  D.6499 = m->least_addr;
  D.6500 = D.6499 <= v;
  D.6501 = (long int) D.6500;
  D.6502 = __builtin_expect (D.6501, 1);
  if (D.6502 != 0) goto <D.6503>; else goto <D.6504>;
  <D.6503>:
  {
    struct malloc_chunk * r;

    r = v + nb;
    D.6505 = v < r;
    D.6506 = (long int) D.6505;
    D.6507 = __builtin_expect (D.6506, 1);
    if (D.6507 != 0) goto <D.6508>; else goto <D.6509>;
    <D.6508>:
    {
      struct malloc_tree_chunk * XP;
      struct malloc_tree_chunk * R;

      XP = v->parent;
      D.6510 = v->bk;
      if (D.6510 != v) goto <D.6511>; else goto <D.6512>;
      <D.6511>:
      {
        struct malloc_tree_chunk * F;

        F = v->fd;
        R = v->bk;
        D.6499 = m->least_addr;
        D.6513 = D.6499 <= F;
        D.6514 = (long int) D.6513;
        D.6515 = __builtin_expect (D.6514, 1);
        if (D.6515 != 0) goto <D.6516>; else goto <D.6517>;
        <D.6516>:
        F->bk = R;
        R->fd = F;
        goto <D.6518>;
        <D.6517>:
        abort ();
        <D.6518>:
      }
      goto <D.6519>;
      <D.6512>:
      {
        struct malloc_tree_chunk * * RP;

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

          goto <D.5951>;
          <D.5950>:
          RP = CP;
          R = *RP;
          <D.5951>:
          CP = &R->child[1];
          D.6523 = *CP;
          if (D.6523 != 0B) goto <D.5950>; else goto <D.6524>;
          <D.6524>:
          CP = &R->child[0];
          D.6523 = *CP;
          if (D.6523 != 0B) goto <D.5950>; else goto <D.5952>;
          <D.5952>:
          D.6499 = m->least_addr;
          D.6525 = D.6499 <= RP;
          D.6526 = (long int) D.6525;
          D.6527 = __builtin_expect (D.6526, 1);
          if (D.6527 != 0) goto <D.6528>; else goto <D.6529>;
          <D.6528>:
          *RP = 0B;
          goto <D.6530>;
          <D.6529>:
          abort ();
          <D.6530>:
        }
        <D.6521>:
      }
      <D.6519>:
      if (XP != 0B) goto <D.6531>; else goto <D.6532>;
      <D.6531>:
      {
        struct malloc_tree_chunk * * H;

        D.6533 = v->index;
        H = &m->treebins[D.6533];
        D.6534 = *H;
        if (D.6534 == v) goto <D.6535>; else goto <D.6536>;
        <D.6535>:
        *H = R;
        D.6534 = *H;
        if (D.6534 == 0B) goto <D.6537>; else goto <D.6538>;
        <D.6537>:
        D.6473 = m->treemap;
        D.6533 = v->index;
        D.6539 = (int) D.6533;
        D.6540 = 1 << D.6539;
        D.6541 = ~D.6540;
        D.6542 = D.6473 & D.6541;
        m->treemap = D.6542;
        <D.6538>:
        goto <D.6543>;
        <D.6536>:
        D.6499 = m->least_addr;
        D.6544 = D.6499 <= XP;
        D.6545 = (long int) D.6544;
        D.6546 = __builtin_expect (D.6545, 1);
        if (D.6546 != 0) goto <D.6547>; else goto <D.6548>;
        <D.6547>:
        D.6549 = XP->child[0];
        if (D.6549 == v) goto <D.6550>; else goto <D.6551>;
        <D.6550>:
        XP->child[0] = R;
        goto <D.6552>;
        <D.6551>:
        XP->child[1] = R;
        <D.6552>:
        goto <D.6553>;
        <D.6548>:
        abort ();
        <D.6553>:
        <D.6543>:
        if (R != 0B) goto <D.6554>; else goto <D.6555>;
        <D.6554>:
        D.6499 = m->least_addr;
        D.6556 = D.6499 <= R;
        D.6557 = (long int) D.6556;
        D.6558 = __builtin_expect (D.6557, 1);
        if (D.6558 != 0) goto <D.6559>; else goto <D.6560>;
        <D.6559>:
        {
          struct malloc_tree_chunk * C0;
          struct malloc_tree_chunk * C1;

          R->parent = XP;
          C0 = v->child[0];
          if (C0 != 0B) goto <D.6561>; else goto <D.6562>;
          <D.6561>:
          D.6499 = m->least_addr;
          D.6563 = D.6499 <= C0;
          D.6564 = (long int) D.6563;
          D.6565 = __builtin_expect (D.6564, 1);
          if (D.6565 != 0) goto <D.6566>; else goto <D.6567>;
          <D.6566>:
          R->child[0] = C0;
          C0->parent = R;
          goto <D.6568>;
          <D.6567>:
          abort ();
          <D.6568>:
          <D.6562>:
          C1 = v->child[1];
          if (C1 != 0B) goto <D.6569>; else goto <D.6570>;
          <D.6569>:
          D.6499 = m->least_addr;
          D.6571 = D.6499 <= C1;
          D.6572 = (long int) D.6571;
          D.6573 = __builtin_expect (D.6572, 1);
          if (D.6573 != 0) goto <D.6574>; else goto <D.6575>;
          <D.6574>:
          R->child[1] = C1;
          C1->parent = R;
          goto <D.6576>;
          <D.6575>:
          abort ();
          <D.6576>:
          <D.6570>:
        }
        goto <D.6577>;
        <D.6560>:
        abort ();
        <D.6577>:
        <D.6555>:
      }
      <D.6532>:
    }
    if (rsize <= 31) goto <D.6578>; else goto <D.6579>;
    <D.6578>:
    D.6580 = rsize + nb;
    D.6581 = D.6580 | 3;
    v->head = D.6581;
    D.6580 = rsize + nb;
    D.6582 = v + D.6580;
    D.6580 = rsize + nb;
    D.6582 = v + D.6580;
    D.6583 = D.6582->head;
    D.6584 = D.6583 | 1;
    D.6582->head = D.6584;
    goto <D.6585>;
    <D.6579>:
    D.6586 = nb | 3;
    v->head = D.6586;
    D.6587 = rsize | 1;
    r->head = D.6587;
    D.6588 = r + rsize;
    D.6588->prev_foot = rsize;
    D.6589 = rsize >> 3;
    if (D.6589 <= 31) goto <D.6590>; else goto <D.6591>;
    <D.6590>:
    {
      bindex_t I;
      struct malloc_chunk * B;
      struct malloc_chunk * F;

      D.6589 = rsize >> 3;
      I = (bindex_t) D.6589;
      D.6592 = I << 1;
      B = &m->smallbins[D.6592];
      F = B;
      D.6593 = m->smallmap;
      I.27 = (int) I;
      D.6595 = 1 << I.27;
      D.6596 = D.6593 & D.6595;
      if (D.6596 == 0) goto <D.6597>; else goto <D.6598>;
      <D.6597>:
      D.6593 = m->smallmap;
      I.27 = (int) I;
      D.6595 = 1 << I.27;
      D.6599 = D.6593 | D.6595;
      m->smallmap = D.6599;
      goto <D.6600>;
      <D.6598>:
      D.6601 = B->fd;
      D.6499 = m->least_addr;
      D.6602 = D.6601 >= D.6499;
      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>:
      F = B->fd;
      goto <D.6607>;
      <D.6606>:
      abort ();
      <D.6607>:
      <D.6600>:
      B->fd = r;
      F->bk = r;
      r->fd = F;
      r->bk = B;
    }
    goto <D.6608>;
    <D.6591>:
    {
      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.6609>; else goto <D.6610>;
          <D.6609>:
          I = 0;
          goto <D.6611>;
          <D.6610>:
          if (X > 65535) goto <D.6612>; else goto <D.6613>;
          <D.6612>:
          I = 31;
          goto <D.6614>;
          <D.6613>:
          {
            unsigned int Y;
            unsigned int N;
            unsigned int K;

            Y = (unsigned int) X;
            D.6615 = Y + 4294967040;
            D.6616 = D.6615 >> 16;
            N = D.6616 & 8;
            N.28 = (int) N;
            Y = Y << N.28;
            D.6618 = Y + 4294963200;
            D.6619 = D.6618 >> 16;
            K = D.6619 & 4;
            N = N + K;
            K.29 = (int) K;
            Y = Y << K.29;
            D.6621 = Y + 4294950912;
            D.6622 = D.6621 >> 16;
            K = D.6622 & 2;
            K.30 = K;
            N = K.30 + N;
            K.29 = (int) K;
            Y = Y << K.29;
            D.6624 = Y >> 15;
            D.6625 = D.6624 - N;
            K = D.6625 + 14;
            D.6626 = K << 1;
            D.6627 = K + 7;
            D.6628 = (int) D.6627;
            D.6629 = rsize >> D.6628;
            D.6630 = (unsigned int) D.6629;
            D.6631 = D.6630 & 1;
            I = D.6626 + D.6631;
          }
          <D.6614>:
          <D.6611>:
        }
        H = &m->treebins[I];
        TP->index = I;
        TP->child[1] = 0B;
        D.6632 = TP->child[1];
        TP->child[0] = D.6632;
        D.6473 = m->treemap;
        I.31 = (int) I;
        D.6634 = 1 << I.31;
        D.6635 = D.6473 & D.6634;
        if (D.6635 == 0) goto <D.6636>; else goto <D.6637>;
        <D.6636>:
        D.6473 = m->treemap;
        I.31 = (int) I;
        D.6634 = 1 << I.31;
        D.6638 = D.6473 | D.6634;
        m->treemap = D.6638;
        *H = TP;
        TP->parent = H;
        TP->bk = TP;
        D.6639 = TP->bk;
        TP->fd = D.6639;
        goto <D.6640>;
        <D.6637>:
        {
          struct malloc_tree_chunk * T;
          size_t K;

          T = *H;
          if (I != 31) goto <D.6642>; else goto <D.6643>;
          <D.6642>:
          D.6644 = I >> 1;
          D.6645 = D.6644 + 6;
          D.6646 = (long unsigned int) D.6645;
          D.6647 = 63 - D.6646;
          iftmp.32 = (int) D.6647;
          goto <D.6648>;
          <D.6643>:
          iftmp.32 = 0;
          <D.6648>:
          K = rsize << iftmp.32;
          <D.5971>:
          D.6649 = T->head;
          D.6650 = D.6649 & 18446744073709551612;
          if (D.6650 != rsize) goto <D.6651>; else goto <D.6652>;
          <D.6651>:
          {
            struct malloc_tree_chunk * * C;

            D.6653 = K >> 63;
            C = &T->child[D.6653];
            K = K << 1;
            D.6654 = *C;
            if (D.6654 != 0B) goto <D.6655>; else goto <D.6656>;
            <D.6655>:
            T = *C;
            goto <D.6657>;
            <D.6656>:
            D.6499 = m->least_addr;
            D.6658 = D.6499 <= C;
            D.6659 = (long int) D.6658;
            D.6660 = __builtin_expect (D.6659, 1);
            if (D.6660 != 0) goto <D.6661>; else goto <D.6662>;
            <D.6661>:
            *C = TP;
            TP->parent = T;
            TP->bk = TP;
            D.6639 = TP->bk;
            TP->fd = D.6639;
            goto <D.5969>;
            <D.6662>:
            abort ();
            <D.6657>:
          }
          goto <D.6663>;
          <D.6652>:
          {
            struct malloc_tree_chunk * F;

            F = T->fd;
            D.6499 = m->least_addr;
            D.6665 = D.6499 <= T;
            D.6666 = (long int) D.6665;
            D.6667 = __builtin_expect (D.6666, 1);
            if (D.6667 != 0) goto <D.6668>; else goto <D.6664>;
            <D.6668>:
            D.6499 = m->least_addr;
            D.6669 = D.6499 <= F;
            D.6670 = (long int) D.6669;
            D.6671 = __builtin_expect (D.6670, 1);
            if (D.6671 != 0) goto <D.6672>; else goto <D.6664>;
            <D.6672>:
            F->bk = TP;
            D.6673 = F->bk;
            T->fd = D.6673;
            TP->fd = F;
            TP->bk = T;
            TP->parent = 0B;
            goto <D.5969>;
            <D.6664>:
            abort ();
          }
          <D.6663>:
          goto <D.5971>;
          <D.5969>:
        }
        <D.6640>:
      }
    }
    <D.6608>:
    <D.6585>:
    D.6674 = v + 16;
    return D.6674;
    <D.6509>:
  }
  <D.6504>:
  abort ();
  <D.6498>:
  <D.6494>:
  D.6674 = 0B;
  return D.6674;
}


sys_alloc (struct malloc_state * m, size_t nb)
{
  unsigned int D.6676;
  long unsigned int D.6677;
  long unsigned int D.6678;
  long unsigned int D.6681;
  void * D.6686;
  struct malloc_segment * iftmp.33;
  struct malloc_chunk * D.6690;
  long unsigned int D.6698;
  long unsigned int D.6699;
  long unsigned int D.6700;
  long unsigned int D.6701;
  long unsigned int D.6702;
  long unsigned int D.6703;
  long unsigned int base.34;
  long unsigned int D.6705;
  long unsigned int D.6708;
  long unsigned int D.6709;
  long unsigned int D.6710;
  long unsigned int D.6711;
  long unsigned int D.6717;
  long unsigned int D.6718;
  long unsigned int D.6719;
  long unsigned int D.6720;
  char * D.6723;
  long unsigned int D.6724;
  char * D.6725;
  long unsigned int D.6734;
  long unsigned int D.6737;
  long unsigned int D.6738;
  long unsigned int D.6739;
  unsigned int D.6748;
  long unsigned int D.6751;
  long int end.35;
  long int br.36;
  long int D.6768;
  long unsigned int D.6769;
  long unsigned int D.6774;
  long unsigned int D.6775;
  long unsigned int D.6776;
  char * D.6781;
  long unsigned int D.6782;
  long unsigned int D.6785;
  struct malloc_chunk * D.6787;
  long unsigned int D.6788;
  sizetype D.6789;
  sizetype D.6790;
  char * D.6791;
  long int D.6792;
  long int mn.37;
  long int D.6794;
  long unsigned int D.6795;
  long unsigned int D.6796;
  char * D.6799;
  long unsigned int D.6800;
  char * D.6801;
  unsigned int D.6805;
  unsigned int D.6806;
  long unsigned int D.6808;
  long unsigned int D.6809;
  long unsigned int D.6810;
  long unsigned int D.6814;
  long unsigned int D.6815;
  long unsigned int D.6825;
  struct malloc_chunk * D.6826;
  long unsigned int D.6827;
  long unsigned int D.6828;
  int * D.6829;
  char * tbase;
  size_t tsize;
  flag_t mmap_flag;

  tbase = -1B;
  tsize = 0;
  mmap_flag = 0;
  init_mparams ();
  D.6676 = m->mflags;
  D.6677 = (long unsigned int) D.6676;
  D.6678 = D.6677 & 1;
  if (D.6678 != 0) goto <D.6679>; else goto <D.6680>;
  <D.6679>:
  D.6681 = mparams.mmap_threshold;
  if (D.6681 <= nb) goto <D.6682>; else goto <D.6683>;
  <D.6682>:
  {
    void * mem;

    mem = mmap_alloc (m, nb);
    if (mem != 0B) goto <D.6684>; else goto <D.6685>;
    <D.6684>:
    D.6686 = mem;
    return D.6686;
    <D.6685>:
  }
  <D.6683>:
  <D.6680>:
  if (0 != 0) goto <D.6687>; else goto <D.6688>;
  <D.6687>:
  {
    char * br;
    struct malloc_segment * ss;
    size_t asize;

    br = -1B;
    D.6690 = m->top;
    if (D.6690 != 0B) goto <D.6691>; else goto <D.6692>;
    <D.6691>:
    D.6690 = m->top;
    iftmp.33 = segment_holding (m, D.6690);
    goto <D.6693>;
    <D.6692>:
    iftmp.33 = 0B;
    <D.6693>:
    ss = iftmp.33;
    asize = 0;
    if (ss == 0B) goto <D.6694>; else goto <D.6695>;
    <D.6694>:
    {
      char * base;

      base = -1B;
      if (base != -1B) goto <D.6696>; else goto <D.6697>;
      <D.6696>:
      D.6698 = mparams.granularity;
      D.6699 = D.6698 + nb;
      D.6700 = D.6699 + 73;
      D.6698 = mparams.granularity;
      D.6701 = -D.6698;
      asize = D.6700 & D.6701;
      D.6702 = mparams.page_size;
      D.6703 = D.6702 + 18446744073709551615;
      base.34 = (long unsigned int) base;
      D.6705 = D.6703 & base.34;
      if (D.6705 != 0) goto <D.6706>; else goto <D.6707>;
      <D.6706>:
      D.6702 = mparams.page_size;
      base.34 = (long unsigned int) base;
      D.6708 = D.6702 + base.34;
      D.6702 = mparams.page_size;
      D.6709 = -D.6702;
      D.6710 = D.6708 & D.6709;
      base.34 = (long unsigned int) base;
      D.6711 = D.6710 - base.34;
      asize = D.6711 + asize;
      <D.6707>:
      if (asize <= 9223372036854775806) goto <D.6712>; else goto <D.6713>;
      <D.6712>:
      br = -1B;
      if (br == base) goto <D.6714>; else goto <D.6715>;
      <D.6714>:
      tbase = base;
      tsize = asize;
      <D.6715>:
      <D.6713>:
      <D.6697>:
    }
    goto <D.6716>;
    <D.6695>:
    D.6717 = m->topsize;
    D.6718 = nb - D.6717;
    D.6698 = mparams.granularity;
    D.6719 = D.6718 + D.6698;
    D.6720 = D.6719 + 73;
    D.6698 = mparams.granularity;
    D.6701 = -D.6698;
    asize = D.6720 & D.6701;
    if (asize <= 9223372036854775806) goto <D.6721>; else goto <D.6722>;
    <D.6721>:
    br = -1B;
    D.6723 = ss->base;
    D.6724 = ss->size;
    D.6725 = D.6723 + D.6724;
    if (br == D.6725) goto <D.6726>; else goto <D.6727>;
    <D.6726>:
    tbase = br;
    tsize = asize;
    <D.6727>:
    <D.6722>:
    <D.6716>:
    if (tbase == -1B) goto <D.6728>; else goto <D.6729>;
    <D.6728>:
    if (br != -1B) goto <D.6730>; else goto <D.6731>;
    <D.6730>:
    if (asize <= 9223372036854775806) goto <D.6732>; else goto <D.6733>;
    <D.6732>:
    D.6734 = nb + 73;
    if (D.6734 > asize) goto <D.6735>; else goto <D.6736>;
    <D.6735>:
    {
      size_t esize;

      D.6737 = nb - asize;
      D.6698 = mparams.granularity;
      D.6738 = D.6737 + D.6698;
      D.6739 = D.6738 + 73;
      D.6698 = mparams.granularity;
      D.6701 = -D.6698;
      esize = D.6739 & D.6701;
      if (esize <= 9223372036854775806) goto <D.6740>; else goto <D.6741>;
      <D.6740>:
      {
        char * end;

        end = -1B;
        if (end != -1B) goto <D.6742>; else goto <D.6743>;
        <D.6742>:
        asize = asize + esize;
        goto <D.6744>;
        <D.6743>:
        br = -1B;
        <D.6744>:
      }
      <D.6741>:
    }
    <D.6736>:
    <D.6733>:
    <D.6731>:
    if (br != -1B) goto <D.6745>; else goto <D.6746>;
    <D.6745>:
    tbase = br;
    tsize = asize;
    goto <D.6747>;
    <D.6746>:
    D.6676 = m->mflags;
    D.6748 = D.6676 | 4;
    m->mflags = D.6748;
    <D.6747>:
    <D.6729>:
  }
  <D.6688>:
  if (tbase == -1B) goto <D.6749>; else goto <D.6750>;
  <D.6749>:
  {
    size_t req;
    size_t rsize;

    req = nb + 73;
    D.6698 = mparams.granularity;
    D.6751 = D.6698 + req;
    D.6698 = mparams.granularity;
    D.6701 = -D.6698;
    rsize = D.6751 & D.6701;
    if (rsize > nb) goto <D.6752>; else goto <D.6753>;
    <D.6752>:
    {
      char * mp;

      mp = mmap (0B, rsize, 7, 34, -1, 0);
      if (mp != -1B) goto <D.6754>; else goto <D.6755>;
      <D.6754>:
      tbase = mp;
      tsize = rsize;
      mmap_flag = 1;
      <D.6755>:
    }
    <D.6753>:
  }
  <D.6750>:
  if (0 != 0) goto <D.6756>; else goto <D.6757>;
  <D.6756>:
  {
    size_t asize;

    D.6698 = mparams.granularity;
    D.6699 = D.6698 + nb;
    D.6700 = D.6699 + 73;
    D.6698 = mparams.granularity;
    D.6701 = -D.6698;
    asize = D.6700 & D.6701;
    if (asize <= 9223372036854775806) goto <D.6758>; else goto <D.6759>;
    <D.6758>:
    {
      char * br;
      char * end;

      br = -1B;
      end = -1B;
      br = -1B;
      end = -1B;
      if (br != -1B) goto <D.6760>; else goto <D.6761>;
      <D.6760>:
      if (end != -1B) goto <D.6762>; else goto <D.6763>;
      <D.6762>:
      if (br < end) goto <D.6764>; else goto <D.6765>;
      <D.6764>:
      {
        size_t ssize;

        end.35 = (long int) end;
        br.36 = (long int) br;
        D.6768 = end.35 - br.36;
        ssize = (size_t) D.6768;
        D.6769 = nb + 72;
        if (D.6769 < ssize) goto <D.6770>; else goto <D.6771>;
        <D.6770>:
        tbase = br;
        tsize = ssize;
        <D.6771>:
      }
      <D.6765>:
      <D.6763>:
      <D.6761>:
    }
    <D.6759>:
  }
  <D.6757>:
  if (tbase != -1B) goto <D.6772>; else goto <D.6773>;
  <D.6772>:
  D.6774 = m->footprint;
  D.6775 = D.6774 + tsize;
  m->footprint = D.6775;
  D.6774 = m->footprint;
  D.6776 = m->max_footprint;
  if (D.6774 > D.6776) goto <D.6777>; else goto <D.6778>;
  <D.6777>:
  D.6774 = m->footprint;
  m->max_footprint = D.6774;
  <D.6778>:
  D.6690 = m->top;
  if (D.6690 == 0B) goto <D.6779>; else goto <D.6780>;
  <D.6779>:
  m->least_addr = tbase;
  D.6781 = m->least_addr;
  m->seg.base = D.6781;
  m->seg.size = tsize;
  m->seg.sflags = mmap_flag;
  D.6782 = mparams.magic;
  m->magic = D.6782;
  init_bins (m);
  if (m == &_gm_) goto <D.6783>; else goto <D.6784>;
  <D.6783>:
  D.6785 = tsize + 18446744073709551544;
  init_top (m, tbase, D.6785);
  goto <D.6786>;
  <D.6784>:
  {
    struct malloc_chunk * mn;

    D.6787 = m + 18446744073709551600;
    D.6788 = D.6787->head;
    D.6789 = D.6788 & 18446744073709551612;
    D.6790 = D.6789 + 18446744073709551600;
    mn = m + D.6790;
    D.6791 = tbase + tsize;
    D.6792 = (long int) D.6791;
    mn.37 = (long int) mn;
    D.6794 = D.6792 - mn.37;
    D.6795 = (long unsigned int) D.6794;
    D.6796 = D.6795 + 18446744073709551544;
    init_top (m, mn, D.6796);
  }
  <D.6786>:
  goto <D.6797>;
  <D.6780>:
  {
    struct malloc_segment * sp;

    sp = &m->seg;
    goto <D.5857>;
    <D.5856>:
    sp = sp->next;
    <D.5857>:
    if (sp != 0B) goto <D.6798>; else goto <D.5858>;
    <D.6798>:
    D.6799 = sp->base;
    D.6800 = sp->size;
    D.6801 = D.6799 + D.6800;
    if (D.6801 != tbase) goto <D.5856>; else goto <D.5858>;
    <D.5858>:
    if (sp != 0B) goto <D.6804>; else goto <D.6802>;
    <D.6804>:
    D.6805 = sp->sflags;
    D.6806 = D.6805 & 8;
    if (D.6806 == 0) goto <D.6807>; else goto <D.6802>;
    <D.6807>:
    D.6805 = sp->sflags;
    D.6808 = (long unsigned int) D.6805;
    D.6809 = D.6808 & 1;
    D.6810 = (long unsigned int) mmap_flag;
    if (D.6809 == D.6810) goto <D.6811>; else goto <D.6802>;
    <D.6811>:
    D.6690 = m->top;
    D.6799 = sp->base;
    if (D.6690 >= D.6799) goto <D.6812>; else goto <D.6802>;
    <D.6812>:
    D.6690 = m->top;
    D.6799 = sp->base;
    D.6800 = sp->size;
    D.6801 = D.6799 + D.6800;
    if (D.6690 < D.6801) goto <D.6813>; else goto <D.6802>;
    <D.6813>:
    D.6800 = sp->size;
    D.6814 = D.6800 + tsize;
    sp->size = D.6814;
    D.6690 = m->top;
    D.6717 = m->topsize;
    D.6815 = D.6717 + tsize;
    init_top (m, D.6690, D.6815);
    goto <D.6803>;
    <D.6802>:
    D.6781 = m->least_addr;
    if (D.6781 > tbase) goto <D.6816>; else goto <D.6817>;
    <D.6816>:
    m->least_addr = tbase;
    <D.6817>:
    sp = &m->seg;
    goto <D.5860>;
    <D.5859>:
    sp = sp->next;
    <D.5860>:
    if (sp != 0B) goto <D.6818>; else goto <D.5861>;
    <D.6818>:
    D.6799 = sp->base;
    D.6791 = tbase + tsize;
    if (D.6799 != D.6791) goto <D.5859>; else goto <D.5861>;
    <D.5861>:
    if (sp != 0B) goto <D.6820>; else goto <D.6819>;
    <D.6820>:
    D.6805 = sp->sflags;
    D.6806 = D.6805 & 8;
    if (D.6806 == 0) goto <D.6821>; else goto <D.6819>;
    <D.6821>:
    D.6805 = sp->sflags;
    D.6808 = (long unsigned int) D.6805;
    D.6809 = D.6808 & 1;
    D.6810 = (long unsigned int) mmap_flag;
    if (D.6809 == D.6810) goto <D.6822>; else goto <D.6819>;
    <D.6822>:
    {
      char * oldbase;

      oldbase = sp->base;
      sp->base = tbase;
      D.6800 = sp->size;
      D.6814 = D.6800 + tsize;
      sp->size = D.6814;
      D.6686 = prepend_alloc (m, tbase, oldbase, nb);
      return D.6686;
    }
    <D.6819>:
    add_segment (m, tbase, tsize, mmap_flag);
    <D.6803>:
  }
  <D.6797>:
  D.6717 = m->topsize;
  if (D.6717 > nb) goto <D.6823>; else goto <D.6824>;
  <D.6823>:
  {
    size_t rsize;
    struct malloc_chunk * p;
    struct malloc_chunk * r;

    D.6717 = m->topsize;
    D.6825 = D.6717 - nb;
    m->topsize = D.6825;
    rsize = m->topsize;
    p = m->top;
    D.6826 = p + nb;
    m->top = D.6826;
    r = m->top;
    D.6827 = rsize | 1;
    r->head = D.6827;
    D.6828 = nb | 3;
    p->head = D.6828;
    D.6686 = p + 16;
    return D.6686;
  }
  <D.6824>:
  <D.6773>:
  D.6829 = __errno_location ();
  *D.6829 = 12;
  D.6686 = 0B;
  return D.6686;
}


mmap_alloc (struct malloc_state * m, size_t nb)
{
  long unsigned int D.6831;
  long unsigned int D.6832;
  long unsigned int D.6833;
  long unsigned int D.6834;
  long unsigned int iftmp.38;
  void * D.6840;
  long unsigned int D.6841;
  long unsigned int D.6842;
  long unsigned int D.6845;
  long unsigned int D.6847;
  long unsigned int D.6848;
  long unsigned int D.6849;
  struct malloc_chunk * D.6850;
  sizetype D.6851;
  struct malloc_chunk * D.6852;
  char * D.6853;
  long unsigned int D.6856;
  long unsigned int D.6857;
  long unsigned int D.6858;
  void * D.6861;
  size_t mmsize;

  D.6831 = mparams.granularity;
  D.6832 = D.6831 + nb;
  D.6833 = D.6832 + 55;
  D.6831 = mparams.granularity;
  D.6834 = -D.6831;
  mmsize = D.6833 & D.6834;
  if (mmsize > nb) goto <D.6835>; else goto <D.6836>;
  <D.6835>:
  {
    char * mm;

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

      D.6840 = mm + 16;
      D.6841 = (long unsigned int) D.6840;
      D.6842 = D.6841 & 7;
      if (D.6842 != 0) goto <D.6843>; else goto <D.6844>;
      <D.6843>:
      D.6840 = mm + 16;
      D.6841 = (long unsigned int) D.6840;
      D.6845 = -D.6841;
      iftmp.38 = D.6845 & 7;
      goto <D.6846>;
      <D.6844>:
      iftmp.38 = 0;
      <D.6846>:
      offset = iftmp.38;
      D.6847 = mmsize - offset;
      psize = D.6847 + 18446744073709551584;
      p = mm + offset;
      D.6848 = offset | 1;
      p->prev_foot = D.6848;
      D.6849 = psize | 2;
      p->head = D.6849;
      D.6850 = p + psize;
      D.6850->head = 11;
      D.6851 = psize + 8;
      D.6852 = p + D.6851;
      D.6852->head = 0;
      D.6853 = m->least_addr;
      if (D.6853 > mm) goto <D.6854>; else goto <D.6855>;
      <D.6854>:
      m->least_addr = mm;
      <D.6855>:
      D.6856 = m->footprint;
      D.6857 = D.6856 + mmsize;
      m->footprint = D.6857;
      D.6856 = m->footprint;
      D.6858 = m->max_footprint;
      if (D.6856 > D.6858) goto <D.6859>; else goto <D.6860>;
      <D.6859>:
      D.6856 = m->footprint;
      m->max_footprint = D.6856;
      <D.6860>:
      D.6861 = p + 16;
      return D.6861;
    }
    <D.6838>:
  }
  <D.6836>:
  D.6861 = 0B;
  return D.6861;
}


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

  i = 0;
  goto <D.5745>;
  <D.5744>:
  {
    struct malloc_chunk * bin;

    D.6863 = i << 1;
    bin = &m->smallbins[D.6863];
    bin->bk = bin;
    D.6864 = bin->bk;
    bin->fd = D.6864;
  }
  i = i + 1;
  <D.5745>:
  if (i <= 31) goto <D.5744>; else goto <D.5746>;
  <D.5746>:
}


init_top (struct malloc_state * m, struct malloc_chunk * p, size_t psize)
{
  long unsigned int iftmp.39;
  void * D.6866;
  long unsigned int D.6867;
  long unsigned int D.6868;
  long unsigned int D.6871;
  long unsigned int D.6873;
  struct malloc_chunk * D.6874;
  long unsigned int D.6875;
  size_t offset;

  D.6866 = p + 16;
  D.6867 = (long unsigned int) D.6866;
  D.6868 = D.6867 & 7;
  if (D.6868 != 0) goto <D.6869>; else goto <D.6870>;
  <D.6869>:
  D.6866 = p + 16;
  D.6867 = (long unsigned int) D.6866;
  D.6871 = -D.6867;
  iftmp.39 = D.6871 & 7;
  goto <D.6872>;
  <D.6870>:
  iftmp.39 = 0;
  <D.6872>:
  offset = iftmp.39;
  p = p + offset;
  psize = psize - offset;
  m->top = p;
  m->topsize = psize;
  D.6873 = psize | 1;
  p->head = D.6873;
  D.6874 = p + psize;
  D.6874->head = 72;
  D.6875 = mparams.trim_threshold;
  m->trim_check = D.6875;
}


prepend_alloc (struct malloc_state * m, char * newbase, char * oldbase, size_t nb)
{
  sizetype iftmp.40;
  void * D.6877;
  long unsigned int D.6878;
  long unsigned int D.6879;
  long unsigned int D.6882;
  sizetype iftmp.41;
  void * D.6885;
  long unsigned int D.6886;
  long unsigned int D.6887;
  long unsigned int D.6890;
  long int oldfirst.42;
  long int p.43;
  long int D.6894;
  long unsigned int D.6895;
  struct malloc_chunk * D.6896;
  long unsigned int D.6899;
  long unsigned int D.6900;
  long unsigned int D.6901;
  struct malloc_chunk * D.6903;
  long unsigned int D.6906;
  long unsigned int D.6907;
  long unsigned int D.6908;
  struct malloc_chunk * D.6909;
  long unsigned int D.6911;
  long unsigned int D.6912;
  long unsigned int D.6915;
  unsigned int D.6920;
  int I.44;
  unsigned int D.6922;
  unsigned int D.6923;
  unsigned int D.6924;
  int iftmp.45;
  unsigned int D.6932;
  struct malloc_chunk * * D.6933;
  _Bool D.6934;
  long int D.6935;
  long int D.6936;
  char * D.6938;
  _Bool D.6939;
  long int D.6940;
  long int D.6941;
  int iftmp.46;
  _Bool D.6947;
  long int D.6948;
  long int D.6949;
  _Bool D.6951;
  long int D.6952;
  long int D.6953;
  struct malloc_tree_chunk * D.6956;
  _Bool D.6959;
  long int D.6960;
  long int D.6961;
  struct malloc_tree_chunk * D.6969;
  _Bool D.6971;
  long int D.6972;
  long int D.6973;
  unsigned int D.6979;
  struct malloc_tree_chunk * D.6980;
  unsigned int D.6985;
  int D.6986;
  unsigned int D.6987;
  unsigned int D.6988;
  unsigned int D.6989;
  _Bool D.6991;
  long int D.6992;
  long int D.6993;
  struct malloc_tree_chunk * D.6996;
  _Bool D.7003;
  long int D.7004;
  long int D.7005;
  _Bool D.7010;
  long int D.7011;
  long int D.7012;
  _Bool D.7018;
  long int D.7019;
  long int D.7020;
  long unsigned int D.7025;
  long unsigned int D.7026;
  struct malloc_chunk * D.7027;
  long unsigned int D.7028;
  unsigned int D.7031;
  int I.47;
  unsigned int D.7033;
  unsigned int D.7034;
  unsigned int D.7037;
  struct malloc_chunk * D.7039;
  _Bool D.7040;
  long int D.7041;
  long int D.7042;
  unsigned int D.7053;
  unsigned int D.7054;
  int N.48;
  unsigned int D.7056;
  unsigned int D.7057;
  int K.49;
  unsigned int D.7059;
  unsigned int D.7060;
  unsigned int K.50;
  unsigned int D.7062;
  unsigned int D.7063;
  unsigned int D.7064;
  unsigned int D.7065;
  int D.7066;
  long unsigned int D.7067;
  unsigned int D.7068;
  unsigned int D.7069;
  struct malloc_tree_chunk * D.7070;
  int I.51;
  unsigned int D.7072;
  unsigned int D.7073;
  unsigned int D.7076;
  struct malloc_tree_chunk * D.7077;
  int iftmp.52;
  unsigned int D.7082;
  unsigned int D.7083;
  long unsigned int D.7084;
  long unsigned int D.7085;
  long unsigned int D.7087;
  long unsigned int D.7088;
  long unsigned int D.7091;
  struct malloc_tree_chunk * D.7092;
  _Bool D.7096;
  long int D.7097;
  long int D.7098;
  _Bool D.7103;
  long int D.7104;
  long int D.7105;
  _Bool D.7107;
  long int D.7108;
  long int D.7109;
  struct malloc_tree_chunk * D.7111;
  void * D.7112;
  struct malloc_chunk * p;
  struct malloc_chunk * oldfirst;
  size_t psize;
  struct malloc_chunk * q;
  size_t qsize;

  D.6877 = newbase + 16;
  D.6878 = (long unsigned int) D.6877;
  D.6879 = D.6878 & 7;
  if (D.6879 != 0) goto <D.6880>; else goto <D.6881>;
  <D.6880>:
  D.6877 = newbase + 16;
  D.6878 = (long unsigned int) D.6877;
  D.6882 = -D.6878;
  iftmp.40 = D.6882 & 7;
  goto <D.6883>;
  <D.6881>:
  iftmp.40 = 0;
  <D.6883>:
  p = newbase + iftmp.40;
  D.6885 = oldbase + 16;
  D.6886 = (long unsigned int) D.6885;
  D.6887 = D.6886 & 7;
  if (D.6887 != 0) goto <D.6888>; else goto <D.6889>;
  <D.6888>:
  D.6885 = oldbase + 16;
  D.6886 = (long unsigned int) D.6885;
  D.6890 = -D.6886;
  iftmp.41 = D.6890 & 7;
  goto <D.6891>;
  <D.6889>:
  iftmp.41 = 0;
  <D.6891>:
  oldfirst = oldbase + iftmp.41;
  oldfirst.42 = (long int) oldfirst;
  p.43 = (long int) p;
  D.6894 = oldfirst.42 - p.43;
  psize = (size_t) D.6894;
  q = p + nb;
  qsize = psize - nb;
  D.6895 = nb | 3;
  p->head = D.6895;
  D.6896 = m->top;
  if (D.6896 == oldfirst) goto <D.6897>; else goto <D.6898>;
  <D.6897>:
  {
    size_t tsize;

    D.6899 = m->topsize;
    D.6900 = D.6899 + qsize;
    m->topsize = D.6900;
    tsize = m->topsize;
    m->top = q;
    D.6901 = tsize | 1;
    q->head = D.6901;
  }
  goto <D.6902>;
  <D.6898>:
  D.6903 = m->dv;
  if (D.6903 == oldfirst) goto <D.6904>; else goto <D.6905>;
  <D.6904>:
  {
    size_t dsize;

    D.6906 = m->dvsize;
    D.6907 = D.6906 + qsize;
    m->dvsize = D.6907;
    dsize = m->dvsize;
    m->dv = q;
    D.6908 = dsize | 1;
    q->head = D.6908;
    D.6909 = q + dsize;
    D.6909->prev_foot = dsize;
  }
  goto <D.6910>;
  <D.6905>:
  D.6911 = oldfirst->head;
  D.6912 = D.6911 & 2;
  if (D.6912 == 0) goto <D.6913>; else goto <D.6914>;
  <D.6913>:
  {
    size_t nsize;

    D.6911 = oldfirst->head;
    nsize = D.6911 & 18446744073709551612;
    D.6915 = nsize >> 3;
    if (D.6915 <= 31) goto <D.6916>; else goto <D.6917>;
    <D.6916>:
    {
      struct malloc_chunk * F;
      struct malloc_chunk * B;
      bindex_t I;

      F = oldfirst->fd;
      B = oldfirst->bk;
      D.6915 = nsize >> 3;
      I = (bindex_t) D.6915;
      if (F == B) goto <D.6918>; else goto <D.6919>;
      <D.6918>:
      D.6920 = m->smallmap;
      I.44 = (int) I;
      D.6922 = 1 << I.44;
      D.6923 = ~D.6922;
      D.6924 = D.6920 & D.6923;
      m->smallmap = D.6924;
      goto <D.6925>;
      <D.6919>:
      D.6932 = I << 1;
      D.6933 = &m->smallbins[D.6932];
      D.6934 = D.6933 == F;
      D.6935 = (long int) D.6934;
      D.6936 = __builtin_expect (D.6935, 1);
      if (D.6936 != 0) goto <D.6929>; else goto <D.6937>;
      <D.6937>:
      D.6938 = m->least_addr;
      D.6939 = D.6938 <= F;
      D.6940 = (long int) D.6939;
      D.6941 = __builtin_expect (D.6940, 1);
      if (D.6941 != 0) goto <D.6929>; else goto <D.6930>;
      <D.6929>:
      iftmp.45 = 1;
      goto <D.6931>;
      <D.6930>:
      iftmp.45 = 0;
      <D.6931>:
      if (iftmp.45 != 0) goto <D.6942>; else goto <D.6926>;
      <D.6942>:
      D.6932 = I << 1;
      D.6933 = &m->smallbins[D.6932];
      D.6947 = D.6933 == B;
      D.6948 = (long int) D.6947;
      D.6949 = __builtin_expect (D.6948, 1);
      if (D.6949 != 0) goto <D.6944>; else goto <D.6950>;
      <D.6950>:
      D.6938 = m->least_addr;
      D.6951 = D.6938 <= B;
      D.6952 = (long int) D.6951;
      D.6953 = __builtin_expect (D.6952, 1);
      if (D.6953 != 0) goto <D.6944>; else goto <D.6945>;
      <D.6944>:
      iftmp.46 = 1;
      goto <D.6946>;
      <D.6945>:
      iftmp.46 = 0;
      <D.6946>:
      if (iftmp.46 != 0) goto <D.6954>; else goto <D.6926>;
      <D.6954>:
      F->bk = B;
      B->fd = F;
      goto <D.6927>;
      <D.6926>:
      abort ();
      <D.6927>:
      <D.6925>:
    }
    goto <D.6955>;
    <D.6917>:
    {
      struct malloc_tree_chunk * TP;

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

        XP = TP->parent;
        D.6956 = TP->bk;
        if (D.6956 != TP) goto <D.6957>; else goto <D.6958>;
        <D.6957>:
        {
          struct malloc_tree_chunk * F;

          F = TP->fd;
          R = TP->bk;
          D.6938 = m->least_addr;
          D.6959 = D.6938 <= F;
          D.6960 = (long int) D.6959;
          D.6961 = __builtin_expect (D.6960, 1);
          if (D.6961 != 0) goto <D.6962>; else goto <D.6963>;
          <D.6962>:
          F->bk = R;
          R->fd = F;
          goto <D.6964>;
          <D.6963>:
          abort ();
          <D.6964>:
        }
        goto <D.6965>;
        <D.6958>:
        {
          struct malloc_tree_chunk * * RP;

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

            goto <D.5771>;
            <D.5770>:
            RP = CP;
            R = *RP;
            <D.5771>:
            CP = &R->child[1];
            D.6969 = *CP;
            if (D.6969 != 0B) goto <D.5770>; else goto <D.6970>;
            <D.6970>:
            CP = &R->child[0];
            D.6969 = *CP;
            if (D.6969 != 0B) goto <D.5770>; else goto <D.5772>;
            <D.5772>:
            D.6938 = m->least_addr;
            D.6971 = D.6938 <= RP;
            D.6972 = (long int) D.6971;
            D.6973 = __builtin_expect (D.6972, 1);
            if (D.6973 != 0) goto <D.6974>; else goto <D.6975>;
            <D.6974>:
            *RP = 0B;
            goto <D.6976>;
            <D.6975>:
            abort ();
            <D.6976>:
          }
          <D.6967>:
        }
        <D.6965>:
        if (XP != 0B) goto <D.6977>; else goto <D.6978>;
        <D.6977>:
        {
          struct malloc_tree_chunk * * H;

          D.6979 = TP->index;
          H = &m->treebins[D.6979];
          D.6980 = *H;
          if (D.6980 == TP) goto <D.6981>; else goto <D.6982>;
          <D.6981>:
          *H = R;
          D.6980 = *H;
          if (D.6980 == 0B) goto <D.6983>; else goto <D.6984>;
          <D.6983>:
          D.6985 = m->treemap;
          D.6979 = TP->index;
          D.6986 = (int) D.6979;
          D.6987 = 1 << D.6986;
          D.6988 = ~D.6987;
          D.6989 = D.6985 & D.6988;
          m->treemap = D.6989;
          <D.6984>:
          goto <D.6990>;
          <D.6982>:
          D.6938 = m->least_addr;
          D.6991 = D.6938 <= XP;
          D.6992 = (long int) D.6991;
          D.6993 = __builtin_expect (D.6992, 1);
          if (D.6993 != 0) goto <D.6994>; else goto <D.6995>;
          <D.6994>:
          D.6996 = XP->child[0];
          if (D.6996 == TP) goto <D.6997>; else goto <D.6998>;
          <D.6997>:
          XP->child[0] = R;
          goto <D.6999>;
          <D.6998>:
          XP->child[1] = R;
          <D.6999>:
          goto <D.7000>;
          <D.6995>:
          abort ();
          <D.7000>:
          <D.6990>:
          if (R != 0B) goto <D.7001>; else goto <D.7002>;
          <D.7001>:
          D.6938 = m->least_addr;
          D.7003 = D.6938 <= R;
          D.7004 = (long int) D.7003;
          D.7005 = __builtin_expect (D.7004, 1);
          if (D.7005 != 0) goto <D.7006>; else goto <D.7007>;
          <D.7006>:
          {
            struct malloc_tree_chunk * C0;
            struct malloc_tree_chunk * C1;

            R->parent = XP;
            C0 = TP->child[0];
            if (C0 != 0B) goto <D.7008>; else goto <D.7009>;
            <D.7008>:
            D.6938 = m->least_addr;
            D.7010 = D.6938 <= C0;
            D.7011 = (long int) D.7010;
            D.7012 = __builtin_expect (D.7011, 1);
            if (D.7012 != 0) goto <D.7013>; else goto <D.7014>;
            <D.7013>:
            R->child[0] = C0;
            C0->parent = R;
            goto <D.7015>;
            <D.7014>:
            abort ();
            <D.7015>:
            <D.7009>:
            C1 = TP->child[1];
            if (C1 != 0B) goto <D.7016>; else goto <D.7017>;
            <D.7016>:
            D.6938 = m->least_addr;
            D.7018 = D.6938 <= C1;
            D.7019 = (long int) D.7018;
            D.7020 = __builtin_expect (D.7019, 1);
            if (D.7020 != 0) goto <D.7021>; else goto <D.7022>;
            <D.7021>:
            R->child[1] = C1;
            C1->parent = R;
            goto <D.7023>;
            <D.7022>:
            abort ();
            <D.7023>:
            <D.7017>:
          }
          goto <D.7024>;
          <D.7007>:
          abort ();
          <D.7024>:
          <D.7002>:
        }
        <D.6978>:
      }
    }
    <D.6955>:
    oldfirst = oldfirst + nsize;
    qsize = qsize + nsize;
  }
  <D.6914>:
  D.6911 = oldfirst->head;
  D.7025 = D.6911 & 18446744073709551614;
  oldfirst->head = D.7025;
  D.7026 = qsize | 1;
  q->head = D.7026;
  D.7027 = q + qsize;
  D.7027->prev_foot = qsize;
  D.7028 = qsize >> 3;
  if (D.7028 <= 31) goto <D.7029>; else goto <D.7030>;
  <D.7029>:
  {
    bindex_t I;
    struct malloc_chunk * B;
    struct malloc_chunk * F;

    D.7028 = qsize >> 3;
    I = (bindex_t) D.7028;
    D.7031 = I << 1;
    B = &m->smallbins[D.7031];
    F = B;
    D.6920 = m->smallmap;
    I.47 = (int) I;
    D.7033 = 1 << I.47;
    D.7034 = D.6920 & D.7033;
    if (D.7034 == 0) goto <D.7035>; else goto <D.7036>;
    <D.7035>:
    D.6920 = m->smallmap;
    I.47 = (int) I;
    D.7033 = 1 << I.47;
    D.7037 = D.6920 | D.7033;
    m->smallmap = D.7037;
    goto <D.7038>;
    <D.7036>:
    D.7039 = B->fd;
    D.6938 = m->least_addr;
    D.7040 = D.7039 >= D.6938;
    D.7041 = (long int) D.7040;
    D.7042 = __builtin_expect (D.7041, 1);
    if (D.7042 != 0) goto <D.7043>; else goto <D.7044>;
    <D.7043>:
    F = B->fd;
    goto <D.7045>;
    <D.7044>:
    abort ();
    <D.7045>:
    <D.7038>:
    B->fd = q;
    F->bk = q;
    q->fd = F;
    q->bk = B;
  }
  goto <D.7046>;
  <D.7030>:
  {
    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.7047>; else goto <D.7048>;
        <D.7047>:
        I = 0;
        goto <D.7049>;
        <D.7048>:
        if (X > 65535) goto <D.7050>; else goto <D.7051>;
        <D.7050>:
        I = 31;
        goto <D.7052>;
        <D.7051>:
        {
          unsigned int Y;
          unsigned int N;
          unsigned int K;

          Y = (unsigned int) X;
          D.7053 = Y + 4294967040;
          D.7054 = D.7053 >> 16;
          N = D.7054 & 8;
          N.48 = (int) N;
          Y = Y << N.48;
          D.7056 = Y + 4294963200;
          D.7057 = D.7056 >> 16;
          K = D.7057 & 4;
          N = N + K;
          K.49 = (int) K;
          Y = Y << K.49;
          D.7059 = Y + 4294950912;
          D.7060 = D.7059 >> 16;
          K = D.7060 & 2;
          K.50 = K;
          N = K.50 + N;
          K.49 = (int) K;
          Y = Y << K.49;
          D.7062 = Y >> 15;
          D.7063 = D.7062 - N;
          K = D.7063 + 14;
          D.7064 = K << 1;
          D.7065 = K + 7;
          D.7066 = (int) D.7065;
          D.7067 = qsize >> D.7066;
          D.7068 = (unsigned int) D.7067;
          D.7069 = D.7068 & 1;
          I = D.7064 + D.7069;
        }
        <D.7052>:
        <D.7049>:
      }
      H = &m->treebins[I];
      TP->index = I;
      TP->child[1] = 0B;
      D.7070 = TP->child[1];
      TP->child[0] = D.7070;
      D.6985 = m->treemap;
      I.51 = (int) I;
      D.7072 = 1 << I.51;
      D.7073 = D.6985 & D.7072;
      if (D.7073 == 0) goto <D.7074>; else goto <D.7075>;
      <D.7074>:
      D.6985 = m->treemap;
      I.51 = (int) I;
      D.7072 = 1 << I.51;
      D.7076 = D.6985 | D.7072;
      m->treemap = D.7076;
      *H = TP;
      TP->parent = H;
      TP->bk = TP;
      D.7077 = TP->bk;
      TP->fd = D.7077;
      goto <D.7078>;
      <D.7075>:
      {
        struct malloc_tree_chunk * T;
        size_t K;

        T = *H;
        if (I != 31) goto <D.7080>; else goto <D.7081>;
        <D.7080>:
        D.7082 = I >> 1;
        D.7083 = D.7082 + 6;
        D.7084 = (long unsigned int) D.7083;
        D.7085 = 63 - D.7084;
        iftmp.52 = (int) D.7085;
        goto <D.7086>;
        <D.7081>:
        iftmp.52 = 0;
        <D.7086>:
        K = qsize << iftmp.52;
        <D.5791>:
        D.7087 = T->head;
        D.7088 = D.7087 & 18446744073709551612;
        if (D.7088 != qsize) goto <D.7089>; else goto <D.7090>;
        <D.7089>:
        {
          struct malloc_tree_chunk * * C;

          D.7091 = K >> 63;
          C = &T->child[D.7091];
          K = K << 1;
          D.7092 = *C;
          if (D.7092 != 0B) goto <D.7093>; else goto <D.7094>;
          <D.7093>:
          T = *C;
          goto <D.7095>;
          <D.7094>:
          D.6938 = m->least_addr;
          D.7096 = D.6938 <= C;
          D.7097 = (long int) D.7096;
          D.7098 = __builtin_expect (D.7097, 1);
          if (D.7098 != 0) goto <D.7099>; else goto <D.7100>;
          <D.7099>:
          *C = TP;
          TP->parent = T;
          TP->bk = TP;
          D.7077 = TP->bk;
          TP->fd = D.7077;
          goto <D.5789>;
          <D.7100>:
          abort ();
          <D.7095>:
        }
        goto <D.7101>;
        <D.7090>:
        {
          struct malloc_tree_chunk * F;

          F = T->fd;
          D.6938 = m->least_addr;
          D.7103 = D.6938 <= T;
          D.7104 = (long int) D.7103;
          D.7105 = __builtin_expect (D.7104, 1);
          if (D.7105 != 0) goto <D.7106>; else goto <D.7102>;
          <D.7106>:
          D.6938 = m->least_addr;
          D.7107 = D.6938 <= F;
          D.7108 = (long int) D.7107;
          D.7109 = __builtin_expect (D.7108, 1);
          if (D.7109 != 0) goto <D.7110>; else goto <D.7102>;
          <D.7110>:
          F->bk = TP;
          D.7111 = F->bk;
          T->fd = D.7111;
          TP->fd = F;
          TP->bk = T;
          TP->parent = 0B;
          goto <D.5789>;
          <D.7102>:
          abort ();
        }
        <D.7101>:
        goto <D.5791>;
        <D.5789>:
      }
      <D.7078>:
    }
  }
  <D.7046>:
  <D.6910>:
  <D.6902>:
  D.7112 = p + 16;
  return D.7112;
}


add_segment (struct malloc_state * m, char * tbase, size_t tsize, flag_t mmapped)
{
  char * D.7114;
  long unsigned int D.7115;
  sizetype D.7116;
  long unsigned int iftmp.53;
  void * D.7118;
  long unsigned int D.7119;
  long unsigned int D.7120;
  long unsigned int D.7123;
  char * iftmp.54;
  char * D.7126;
  long unsigned int D.7130;
  long unsigned int D.7131;
  size_t * D.7132;
  long int csp.55;
  long int old_top.56;
  long int D.7138;
  long unsigned int D.7139;
  long unsigned int D.7140;
  long unsigned int D.7141;
  struct malloc_chunk * D.7142;
  long unsigned int D.7143;
  unsigned int D.7146;
  unsigned int D.7147;
  int I.57;
  unsigned int D.7149;
  unsigned int D.7150;
  unsigned int D.7153;
  struct malloc_chunk * D.7155;
  char * D.7156;
  _Bool D.7157;
  long int D.7158;
  long int D.7159;
  unsigned int D.7170;
  unsigned int D.7171;
  int N.58;
  unsigned int D.7173;
  unsigned int D.7174;
  int K.59;
  unsigned int D.7176;
  unsigned int D.7177;
  unsigned int K.60;
  unsigned int D.7179;
  unsigned int D.7180;
  unsigned int D.7181;
  unsigned int D.7182;
  int D.7183;
  long unsigned int D.7184;
  unsigned int D.7185;
  unsigned int D.7186;
  struct malloc_tree_chunk * D.7187;
  unsigned int D.7188;
  int I.61;
  unsigned int D.7190;
  unsigned int D.7191;
  unsigned int D.7194;
  struct malloc_tree_chunk * D.7195;
  int iftmp.62;
  unsigned int D.7200;
  unsigned int D.7201;
  long unsigned int D.7202;
  long unsigned int D.7203;
  long unsigned int D.7205;
  long unsigned int D.7206;
  long unsigned int D.7209;
  struct malloc_tree_chunk * D.7210;
  _Bool D.7214;
  long int D.7215;
  long int D.7216;
  _Bool D.7221;
  long int D.7222;
  long int D.7223;
  _Bool D.7225;
  long int D.7226;
  long int D.7227;
  struct malloc_tree_chunk * D.7229;
  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.7114 = oldsp->base;
  D.7115 = oldsp->size;
  old_end = D.7114 + D.7115;
  ssize = 40;
  D.7116 = 18446744073709551577 - ssize;
  rawsp = old_end + D.7116;
  D.7118 = rawsp + 16;
  D.7119 = (long unsigned int) D.7118;
  D.7120 = D.7119 & 7;
  if (D.7120 != 0) goto <D.7121>; else goto <D.7122>;
  <D.7121>:
  D.7118 = rawsp + 16;
  D.7119 = (long unsigned int) D.7118;
  D.7123 = -D.7119;
  iftmp.53 = D.7123 & 7;
  goto <D.7124>;
  <D.7122>:
  iftmp.53 = 0;
  <D.7124>:
  offset = iftmp.53;
  asp = rawsp + offset;
  D.7126 = old_top + 32;
  if (D.7126 > asp) goto <D.7127>; else goto <D.7128>;
  <D.7127>:
  iftmp.54 = old_top;
  goto <D.7129>;
  <D.7128>:
  iftmp.54 = asp;
  <D.7129>:
  csp = iftmp.54;
  sp = csp;
  ss = sp + 16;
  tnext = sp + ssize;
  p = tnext;
  nfences = 0;
  D.7130 = tsize + 18446744073709551544;
  init_top (m, tbase, D.7130);
  D.7131 = ssize | 3;
  sp->head = D.7131;
  *ss = m->seg;
  m->seg.base = tbase;
  m->seg.size = tsize;
  m->seg.sflags = mmapped;
  m->seg.next = ss;
  <D.5813>:
  {
    struct malloc_chunk * nextp;

    nextp = p + 8;
    p->head = 11;
    nfences = nfences + 1;
    D.7132 = &nextp->head;
    if (D.7132 < old_end) goto <D.7133>; else goto <D.5812>;
    <D.7133>:
    p = nextp;
  }
  goto <D.5813>;
  <D.5812>:
  if (csp != old_top) goto <D.7134>; else goto <D.7135>;
  <D.7134>:
  {
    struct malloc_chunk * q;
    size_t psize;
    struct malloc_chunk * tn;

    q = old_top;
    csp.55 = (long int) csp;
    old_top.56 = (long int) old_top;
    D.7138 = csp.55 - old_top.56;
    psize = (size_t) D.7138;
    tn = q + psize;
    D.7139 = tn->head;
    D.7140 = D.7139 & 18446744073709551614;
    tn->head = D.7140;
    D.7141 = psize | 1;
    q->head = D.7141;
    D.7142 = q + psize;
    D.7142->prev_foot = psize;
    D.7143 = psize >> 3;
    if (D.7143 <= 31) goto <D.7144>; else goto <D.7145>;
    <D.7144>:
    {
      bindex_t I;
      struct malloc_chunk * B;
      struct malloc_chunk * F;

      D.7143 = psize >> 3;
      I = (bindex_t) D.7143;
      D.7146 = I << 1;
      B = &m->smallbins[D.7146];
      F = B;
      D.7147 = m->smallmap;
      I.57 = (int) I;
      D.7149 = 1 << I.57;
      D.7150 = D.7147 & D.7149;
      if (D.7150 == 0) goto <D.7151>; else goto <D.7152>;
      <D.7151>:
      D.7147 = m->smallmap;
      I.57 = (int) I;
      D.7149 = 1 << I.57;
      D.7153 = D.7147 | D.7149;
      m->smallmap = D.7153;
      goto <D.7154>;
      <D.7152>:
      D.7155 = B->fd;
      D.7156 = m->least_addr;
      D.7157 = D.7155 >= D.7156;
      D.7158 = (long int) D.7157;
      D.7159 = __builtin_expect (D.7158, 1);
      if (D.7159 != 0) goto <D.7160>; else goto <D.7161>;
      <D.7160>:
      F = B->fd;
      goto <D.7162>;
      <D.7161>:
      abort ();
      <D.7162>:
      <D.7154>:
      B->fd = q;
      F->bk = q;
      q->fd = F;
      q->bk = B;
    }
    goto <D.7163>;
    <D.7145>:
    {
      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.7164>; else goto <D.7165>;
          <D.7164>:
          I = 0;
          goto <D.7166>;
          <D.7165>:
          if (X > 65535) goto <D.7167>; else goto <D.7168>;
          <D.7167>:
          I = 31;
          goto <D.7169>;
          <D.7168>:
          {
            unsigned int Y;
            unsigned int N;
            unsigned int K;

            Y = (unsigned int) X;
            D.7170 = Y + 4294967040;
            D.7171 = D.7170 >> 16;
            N = D.7171 & 8;
            N.58 = (int) N;
            Y = Y << N.58;
            D.7173 = Y + 4294963200;
            D.7174 = D.7173 >> 16;
            K = D.7174 & 4;
            N = N + K;
            K.59 = (int) K;
            Y = Y << K.59;
            D.7176 = Y + 4294950912;
            D.7177 = D.7176 >> 16;
            K = D.7177 & 2;
            K.60 = K;
            N = K.60 + N;
            K.59 = (int) K;
            Y = Y << K.59;
            D.7179 = Y >> 15;
            D.7180 = D.7179 - N;
            K = D.7180 + 14;
            D.7181 = K << 1;
            D.7182 = K + 7;
            D.7183 = (int) D.7182;
            D.7184 = psize >> D.7183;
            D.7185 = (unsigned int) D.7184;
            D.7186 = D.7185 & 1;
            I = D.7181 + D.7186;
          }
          <D.7169>:
          <D.7166>:
        }
        H = &m->treebins[I];
        TP->index = I;
        TP->child[1] = 0B;
        D.7187 = TP->child[1];
        TP->child[0] = D.7187;
        D.7188 = m->treemap;
        I.61 = (int) I;
        D.7190 = 1 << I.61;
        D.7191 = D.7188 & D.7190;
        if (D.7191 == 0) goto <D.7192>; else goto <D.7193>;
        <D.7192>:
        D.7188 = m->treemap;
        I.61 = (int) I;
        D.7190 = 1 << I.61;
        D.7194 = D.7188 | D.7190;
        m->treemap = D.7194;
        *H = TP;
        TP->parent = H;
        TP->bk = TP;
        D.7195 = TP->bk;
        TP->fd = D.7195;
        goto <D.7196>;
        <D.7193>:
        {
          struct malloc_tree_chunk * T;
          size_t K;

          T = *H;
          if (I != 31) goto <D.7198>; else goto <D.7199>;
          <D.7198>:
          D.7200 = I >> 1;
          D.7201 = D.7200 + 6;
          D.7202 = (long unsigned int) D.7201;
          D.7203 = 63 - D.7202;
          iftmp.62 = (int) D.7203;
          goto <D.7204>;
          <D.7199>:
          iftmp.62 = 0;
          <D.7204>:
          K = psize << iftmp.62;
          <D.5832>:
          D.7205 = T->head;
          D.7206 = D.7205 & 18446744073709551612;
          if (D.7206 != psize) goto <D.7207>; else goto <D.7208>;
          <D.7207>:
          {
            struct malloc_tree_chunk * * C;

            D.7209 = K >> 63;
            C = &T->child[D.7209];
            K = K << 1;
            D.7210 = *C;
            if (D.7210 != 0B) goto <D.7211>; else goto <D.7212>;
            <D.7211>:
            T = *C;
            goto <D.7213>;
            <D.7212>:
            D.7156 = m->least_addr;
            D.7214 = D.7156 <= C;
            D.7215 = (long int) D.7214;
            D.7216 = __builtin_expect (D.7215, 1);
            if (D.7216 != 0) goto <D.7217>; else goto <D.7218>;
            <D.7217>:
            *C = TP;
            TP->parent = T;
            TP->bk = TP;
            D.7195 = TP->bk;
            TP->fd = D.7195;
            goto <D.5830>;
            <D.7218>:
            abort ();
            <D.7213>:
          }
          goto <D.7219>;
          <D.7208>:
          {
            struct malloc_tree_chunk * F;

            F = T->fd;
            D.7156 = m->least_addr;
            D.7221 = D.7156 <= T;
            D.7222 = (long int) D.7221;
            D.7223 = __builtin_expect (D.7222, 1);
            if (D.7223 != 0) goto <D.7224>; else goto <D.7220>;
            <D.7224>:
            D.7156 = m->least_addr;
            D.7225 = D.7156 <= F;
            D.7226 = (long int) D.7225;
            D.7227 = __builtin_expect (D.7226, 1);
            if (D.7227 != 0) goto <D.7228>; else goto <D.7220>;
            <D.7228>:
            F->bk = TP;
            D.7229 = F->bk;
            T->fd = D.7229;
            TP->fd = F;
            TP->bk = T;
            TP->parent = 0B;
            goto <D.5830>;
            <D.7220>:
            abort ();
          }
          <D.7219>:
          goto <D.5832>;
          <D.5830>:
        }
        <D.7196>:
      }
    }
    <D.7163>:
  }
  <D.7135>:
}


segment_holding (struct malloc_state * m, char * addr)
{
  char * D.7230;
  long unsigned int D.7233;
  char * D.7234;
  struct malloc_segment * D.7237;
  struct malloc_segment * sp;

  sp = &m->seg;
  <D.5713>:
  D.7230 = sp->base;
  if (D.7230 <= addr) goto <D.7231>; else goto <D.7232>;
  <D.7231>:
  D.7230 = sp->base;
  D.7233 = sp->size;
  D.7234 = D.7230 + D.7233;
  if (D.7234 > addr) goto <D.7235>; else goto <D.7236>;
  <D.7235>:
  D.7237 = sp;
  return D.7237;
  <D.7236>:
  <D.7232>:
  sp = sp->next;
  if (sp == 0B) goto <D.7238>; else goto <D.7239>;
  <D.7238>:
  D.7237 = 0B;
  return D.7237;
  <D.7239>:
  goto <D.5713>;
}


dlfree (void * mem)
{
  long unsigned int D.7247;
  int D.7249;
  unsigned int D.7250;
  unsigned int D.7251;
  int D.7252;
  char * D.7253;
  _Bool D.7254;
  long int D.7255;
  long int D.7256;
  long unsigned int D.7259;
  long unsigned int D.7260;
  _Bool D.7261;
  long int D.7262;
  long int D.7263;
  long unsigned int D.7266;
  long unsigned int D.7269;
  long unsigned int D.7272;
  sizetype D.7273;
  void * D.7274;
  int D.7275;
  long unsigned int D.7278;
  long unsigned int D.7279;
  _Bool D.7280;
  long int D.7281;
  long int D.7282;
  struct malloc_chunk * D.7284;
  long unsigned int D.7287;
  unsigned int D.7292;
  int I.63;
  unsigned int D.7294;
  unsigned int D.7295;
  unsigned int D.7296;
  int iftmp.64;
  unsigned int D.7304;
  struct malloc_chunk * * D.7305;
  _Bool D.7306;
  long int D.7307;
  long int D.7308;
  _Bool D.7310;
  long int D.7311;
  long int D.7312;
  int iftmp.65;
  _Bool D.7318;
  long int D.7319;
  long int D.7320;
  _Bool D.7322;
  long int D.7323;
  long int D.7324;
  struct malloc_tree_chunk * D.7327;
  _Bool D.7330;
  long int D.7331;
  long int D.7332;
  struct malloc_tree_chunk * D.7340;
  _Bool D.7342;
  long int D.7343;
  long int D.7344;
  unsigned int D.7350;
  struct malloc_tree_chunk * D.7351;
  unsigned int D.7356;
  int D.7357;
  unsigned int D.7358;
  unsigned int D.7359;
  unsigned int D.7360;
  _Bool D.7362;
  long int D.7363;
  long int D.7364;
  struct malloc_tree_chunk * D.7367;
  _Bool D.7374;
  long int D.7375;
  long int D.7376;
  _Bool D.7381;
  long int D.7382;
  long int D.7383;
  _Bool D.7389;
  long int D.7390;
  long int D.7391;
  long unsigned int D.7397;
  long unsigned int D.7398;
  long unsigned int D.7401;
  long unsigned int D.7402;
  struct malloc_chunk * D.7403;
  _Bool D.7404;
  long int D.7405;
  long int D.7406;
  long unsigned int D.7409;
  _Bool D.7410;
  long int D.7411;
  long int D.7412;
  long unsigned int D.7415;
  struct malloc_chunk * D.7418;
  long unsigned int D.7421;
  long unsigned int D.7422;
  long unsigned int D.7423;
  long unsigned int D.7426;
  long unsigned int D.7431;
  long unsigned int D.7432;
  long unsigned int D.7433;
  struct malloc_chunk * D.7434;
  long unsigned int D.7435;
  int I.66;
  unsigned int D.7441;
  unsigned int D.7442;
  unsigned int D.7443;
  int iftmp.67;
  unsigned int D.7451;
  struct malloc_chunk * * D.7452;
  _Bool D.7453;
  long int D.7454;
  long int D.7455;
  _Bool D.7457;
  long int D.7458;
  long int D.7459;
  int iftmp.68;
  _Bool D.7465;
  long int D.7466;
  long int D.7467;
  _Bool D.7469;
  long int D.7470;
  long int D.7471;
  struct malloc_tree_chunk * D.7474;
  _Bool D.7477;
  long int D.7478;
  long int D.7479;
  struct malloc_tree_chunk * D.7487;
  _Bool D.7489;
  long int D.7490;
  long int D.7491;
  unsigned int D.7497;
  struct malloc_tree_chunk * D.7498;
  int D.7503;
  unsigned int D.7504;
  unsigned int D.7505;
  unsigned int D.7506;
  _Bool D.7508;
  long int D.7509;
  long int D.7510;
  struct malloc_tree_chunk * D.7513;
  _Bool D.7520;
  long int D.7521;
  long int D.7522;
  _Bool D.7527;
  long int D.7528;
  long int D.7529;
  _Bool D.7535;
  long int D.7536;
  long int D.7537;
  long unsigned int D.7545;
  unsigned int D.7548;
  int I.69;
  unsigned int D.7550;
  unsigned int D.7551;
  unsigned int D.7554;
  struct malloc_chunk * D.7556;
  _Bool D.7557;
  long int D.7558;
  long int D.7559;
  unsigned int D.7570;
  unsigned int D.7571;
  int N.70;
  unsigned int D.7573;
  unsigned int D.7574;
  int K.71;
  unsigned int D.7576;
  unsigned int D.7577;
  unsigned int K.72;
  unsigned int D.7579;
  unsigned int D.7580;
  unsigned int D.7581;
  unsigned int D.7582;
  int D.7583;
  long unsigned int D.7584;
  unsigned int D.7585;
  unsigned int D.7586;
  struct malloc_tree_chunk * D.7587;
  int I.73;
  unsigned int D.7589;
  unsigned int D.7590;
  unsigned int D.7593;
  struct malloc_tree_chunk * D.7594;
  int iftmp.74;
  unsigned int D.7599;
  unsigned int D.7600;
  long unsigned int D.7601;
  long unsigned int D.7602;
  long unsigned int D.7604;
  long unsigned int D.7605;
  long unsigned int D.7608;
  struct malloc_tree_chunk * D.7609;
  _Bool D.7613;
  long int D.7614;
  long int D.7615;
  _Bool D.7620;
  long int D.7621;
  long int D.7622;
  _Bool D.7624;
  long int D.7625;
  long int D.7626;
  struct malloc_tree_chunk * D.7628;
  void postaction = <<< error >>>;
  void erroraction = <<< error >>>;

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

    p = mem + 18446744073709551600;
    D.7247 = mparams.page_size;
    if (D.7247 != 0) goto <D.7243>; else goto <D.7248>;
    <D.7248>:
    D.7249 = init_mparams ();
    if (D.7249 == 0) goto <D.7243>; else goto <D.7244>;
    <D.7243>:
    D.7250 = _gm_.mflags;
    D.7251 = D.7250 & 2;
    if (D.7251 == 0) goto <D.7245>; else goto <D.7244>;
    <D.7244>:
    D.7252 = pthread_mutex_lock (&_gm_.mutex);
    if (D.7252 == 0) goto <D.7245>; else goto <D.7246>;
    <D.7245>:
    D.7253 = _gm_.least_addr;
    D.7254 = D.7253 <= p;
    D.7255 = (long int) D.7254;
    D.7256 = __builtin_expect (D.7255, 1);
    if (D.7256 != 0) goto <D.7257>; else goto <D.7258>;
    <D.7257>:
    D.7259 = p->head;
    D.7260 = D.7259 & 2;
    D.7261 = D.7260 != 0;
    D.7262 = (long int) D.7261;
    D.7263 = __builtin_expect (D.7262, 1);
    if (D.7263 != 0) goto <D.7264>; else goto <D.7265>;
    <D.7264>:
    {
      size_t psize;
      struct malloc_chunk * next;

      D.7259 = p->head;
      psize = D.7259 & 18446744073709551612;
      next = p + psize;
      D.7259 = p->head;
      D.7266 = D.7259 & 1;
      if (D.7266 == 0) goto <D.7267>; else goto <D.7268>;
      <D.7267>:
      {
        size_t prevsize;

        prevsize = p->prev_foot;
        D.7269 = prevsize & 1;
        if (D.7269 != 0) goto <D.7270>; else goto <D.7271>;
        <D.7270>:
        prevsize = prevsize & 18446744073709551614;
        D.7272 = prevsize + psize;
        psize = D.7272 + 32;
        D.7273 = -prevsize;
        D.7274 = p + D.7273;
        D.7275 = munmap (D.7274, psize);
        if (D.7275 == 0) goto <D.7276>; else goto <D.7277>;
        <D.7276>:
        D.7278 = _gm_.footprint;
        D.7279 = D.7278 - psize;
        _gm_.footprint = D.7279;
        <D.7277>:
        goto postaction;
        <D.7271>:
        {
          struct malloc_chunk * prev;

          D.7273 = -prevsize;
          prev = p + D.7273;
          psize = psize + prevsize;
          p = prev;
          D.7253 = _gm_.least_addr;
          D.7280 = D.7253 <= prev;
          D.7281 = (long int) D.7280;
          D.7282 = __builtin_expect (D.7281, 1);
          if (D.7282 != 0) goto <D.7283>; else goto erroraction;
          <D.7283>:
          D.7284 = _gm_.dv;
          if (D.7284 != p) goto <D.7285>; else goto <D.7286>;
          <D.7285>:
          D.7287 = prevsize >> 3;
          if (D.7287 <= 31) goto <D.7288>; else goto <D.7289>;
          <D.7288>:
          {
            struct malloc_chunk * F;
            struct malloc_chunk * B;
            bindex_t I;

            F = p->fd;
            B = p->bk;
            D.7287 = prevsize >> 3;
            I = (bindex_t) D.7287;
            if (F == B) goto <D.7290>; else goto <D.7291>;
            <D.7290>:
            D.7292 = _gm_.smallmap;
            I.63 = (int) I;
            D.7294 = 1 << I.63;
            D.7295 = ~D.7294;
            D.7296 = D.7292 & D.7295;
            _gm_.smallmap = D.7296;
            goto <D.7297>;
            <D.7291>:
            D.7304 = I << 1;
            D.7305 = &_gm_.smallbins[D.7304];
            D.7306 = D.7305 == F;
            D.7307 = (long int) D.7306;
            D.7308 = __builtin_expect (D.7307, 1);
            if (D.7308 != 0) goto <D.7301>; else goto <D.7309>;
            <D.7309>:
            D.7253 = _gm_.least_addr;
            D.7310 = D.7253 <= F;
            D.7311 = (long int) D.7310;
            D.7312 = __builtin_expect (D.7311, 1);
            if (D.7312 != 0) goto <D.7301>; else goto <D.7302>;
            <D.7301>:
            iftmp.64 = 1;
            goto <D.7303>;
            <D.7302>:
            iftmp.64 = 0;
            <D.7303>:
            if (iftmp.64 != 0) goto <D.7313>; else goto <D.7298>;
            <D.7313>:
            D.7304 = I << 1;
            D.7305 = &_gm_.smallbins[D.7304];
            D.7318 = D.7305 == B;
            D.7319 = (long int) D.7318;
            D.7320 = __builtin_expect (D.7319, 1);
            if (D.7320 != 0) goto <D.7315>; else goto <D.7321>;
            <D.7321>:
            D.7253 = _gm_.least_addr;
            D.7322 = D.7253 <= B;
            D.7323 = (long int) D.7322;
            D.7324 = __builtin_expect (D.7323, 1);
            if (D.7324 != 0) goto <D.7315>; else goto <D.7316>;
            <D.7315>:
            iftmp.65 = 1;
            goto <D.7317>;
            <D.7316>:
            iftmp.65 = 0;
            <D.7317>:
            if (iftmp.65 != 0) goto <D.7325>; else goto <D.7298>;
            <D.7325>:
            F->bk = B;
            B->fd = F;
            goto <D.7299>;
            <D.7298>:
            abort ();
            <D.7299>:
            <D.7297>:
          }
          goto <D.7326>;
          <D.7289>:
          {
            struct malloc_tree_chunk * TP;

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

              XP = TP->parent;
              D.7327 = TP->bk;
              if (D.7327 != TP) goto <D.7328>; else goto <D.7329>;
              <D.7328>:
              {
                struct malloc_tree_chunk * F;

                F = TP->fd;
                R = TP->bk;
                D.7253 = _gm_.least_addr;
                D.7330 = D.7253 <= F;
                D.7331 = (long int) D.7330;
                D.7332 = __builtin_expect (D.7331, 1);
                if (D.7332 != 0) goto <D.7333>; else goto <D.7334>;
                <D.7333>:
                F->bk = R;
                R->fd = F;
                goto <D.7335>;
                <D.7334>:
                abort ();
                <D.7335>:
              }
              goto <D.7336>;
              <D.7329>:
              {
                struct malloc_tree_chunk * * RP;

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

                  goto <D.6081>;
                  <D.6080>:
                  RP = CP;
                  R = *RP;
                  <D.6081>:
                  CP = &R->child[1];
                  D.7340 = *CP;
                  if (D.7340 != 0B) goto <D.6080>; else goto <D.7341>;
                  <D.7341>:
                  CP = &R->child[0];
                  D.7340 = *CP;
                  if (D.7340 != 0B) goto <D.6080>; else goto <D.6082>;
                  <D.6082>:
                  D.7253 = _gm_.least_addr;
                  D.7342 = D.7253 <= RP;
                  D.7343 = (long int) D.7342;
                  D.7344 = __builtin_expect (D.7343, 1);
                  if (D.7344 != 0) goto <D.7345>; else goto <D.7346>;
                  <D.7345>:
                  *RP = 0B;
                  goto <D.7347>;
                  <D.7346>:
                  abort ();
                  <D.7347>:
                }
                <D.7338>:
              }
              <D.7336>:
              if (XP != 0B) goto <D.7348>; else goto <D.7349>;
              <D.7348>:
              {
                struct malloc_tree_chunk * * H;

                D.7350 = TP->index;
                H = &_gm_.treebins[D.7350];
                D.7351 = *H;
                if (D.7351 == TP) goto <D.7352>; else goto <D.7353>;
                <D.7352>:
                *H = R;
                D.7351 = *H;
                if (D.7351 == 0B) goto <D.7354>; else goto <D.7355>;
                <D.7354>:
                D.7356 = _gm_.treemap;
                D.7350 = TP->index;
                D.7357 = (int) D.7350;
                D.7358 = 1 << D.7357;
                D.7359 = ~D.7358;
                D.7360 = D.7356 & D.7359;
                _gm_.treemap = D.7360;
                <D.7355>:
                goto <D.7361>;
                <D.7353>:
                D.7253 = _gm_.least_addr;
                D.7362 = D.7253 <= XP;
                D.7363 = (long int) D.7362;
                D.7364 = __builtin_expect (D.7363, 1);
                if (D.7364 != 0) goto <D.7365>; else goto <D.7366>;
                <D.7365>:
                D.7367 = XP->child[0];
                if (D.7367 == TP) goto <D.7368>; else goto <D.7369>;
                <D.7368>:
                XP->child[0] = R;
                goto <D.7370>;
                <D.7369>:
                XP->child[1] = R;
                <D.7370>:
                goto <D.7371>;
                <D.7366>:
                abort ();
                <D.7371>:
                <D.7361>:
                if (R != 0B) goto <D.7372>; else goto <D.7373>;
                <D.7372>:
                D.7253 = _gm_.least_addr;
                D.7374 = D.7253 <= R;
                D.7375 = (long int) D.7374;
                D.7376 = __builtin_expect (D.7375, 1);
                if (D.7376 != 0) goto <D.7377>; else goto <D.7378>;
                <D.7377>:
                {
                  struct malloc_tree_chunk * C0;
                  struct malloc_tree_chunk * C1;

                  R->parent = XP;
                  C0 = TP->child[0];
                  if (C0 != 0B) goto <D.7379>; else goto <D.7380>;
                  <D.7379>:
                  D.7253 = _gm_.least_addr;
                  D.7381 = D.7253 <= C0;
                  D.7382 = (long int) D.7381;
                  D.7383 = __builtin_expect (D.7382, 1);
                  if (D.7383 != 0) goto <D.7384>; else goto <D.7385>;
                  <D.7384>:
                  R->child[0] = C0;
                  C0->parent = R;
                  goto <D.7386>;
                  <D.7385>:
                  abort ();
                  <D.7386>:
                  <D.7380>:
                  C1 = TP->child[1];
                  if (C1 != 0B) goto <D.7387>; else goto <D.7388>;
                  <D.7387>:
                  D.7253 = _gm_.least_addr;
                  D.7389 = D.7253 <= C1;
                  D.7390 = (long int) D.7389;
                  D.7391 = __builtin_expect (D.7390, 1);
                  if (D.7391 != 0) goto <D.7392>; else goto <D.7393>;
                  <D.7392>:
                  R->child[1] = C1;
                  C1->parent = R;
                  goto <D.7394>;
                  <D.7393>:
                  abort ();
                  <D.7394>:
                  <D.7388>:
                }
                goto <D.7395>;
                <D.7378>:
                abort ();
                <D.7395>:
                <D.7373>:
              }
              <D.7349>:
            }
          }
          <D.7326>:
          goto <D.7396>;
          <D.7286>:
          D.7397 = next->head;
          D.7398 = D.7397 & 3;
          if (D.7398 == 3) goto <D.7399>; else goto <D.7400>;
          <D.7399>:
          _gm_.dvsize = psize;
          D.7397 = next->head;
          D.7401 = D.7397 & 18446744073709551614;
          next->head = D.7401;
          D.7402 = psize | 1;
          p->head = D.7402;
          D.7403 = p + psize;
          D.7403->prev_foot = psize;
          goto postaction;
          <D.7400>:
          <D.7396>:
        }
      }
      <D.7268>:
      D.7404 = p < next;
      D.7405 = (long int) D.7404;
      D.7406 = __builtin_expect (D.7405, 1);
      if (D.7406 != 0) goto <D.7407>; else goto <D.7408>;
      <D.7407>:
      D.7397 = next->head;
      D.7409 = D.7397 & 1;
      D.7410 = D.7409 != 0;
      D.7411 = (long int) D.7410;
      D.7412 = __builtin_expect (D.7411, 1);
      if (D.7412 != 0) goto <D.7413>; else goto <D.7414>;
      <D.7413>:
      D.7397 = next->head;
      D.7415 = D.7397 & 2;
      if (D.7415 == 0) goto <D.7416>; else goto <D.7417>;
      <D.7416>:
      D.7418 = _gm_.top;
      if (D.7418 == next) goto <D.7419>; else goto <D.7420>;
      <D.7419>:
      {
        size_t tsize;

        D.7421 = _gm_.topsize;
        D.7422 = D.7421 + psize;
        _gm_.topsize = D.7422;
        tsize = _gm_.topsize;
        _gm_.top = p;
        D.7423 = tsize | 1;
        p->head = D.7423;
        D.7284 = _gm_.dv;
        if (D.7284 == p) goto <D.7424>; else goto <D.7425>;
        <D.7424>:
        _gm_.dv = 0B;
        _gm_.dvsize = 0;
        <D.7425>:
        D.7426 = _gm_.trim_check;
        if (D.7426 < tsize) goto <D.7427>; else goto <D.7428>;
        <D.7427>:
        sys_trim (&_gm_, 0);
        <D.7428>:
        goto postaction;
      }
      <D.7420>:
      D.7284 = _gm_.dv;
      if (D.7284 == next) goto <D.7429>; else goto <D.7430>;
      <D.7429>:
      {
        size_t dsize;

        D.7431 = _gm_.dvsize;
        D.7432 = D.7431 + psize;
        _gm_.dvsize = D.7432;
        dsize = _gm_.dvsize;
        _gm_.dv = p;
        D.7433 = dsize | 1;
        p->head = D.7433;
        D.7434 = p + dsize;
        D.7434->prev_foot = dsize;
        goto postaction;
      }
      <D.7430>:
      {
        size_t nsize;

        D.7397 = next->head;
        nsize = D.7397 & 18446744073709551612;
        psize = psize + nsize;
        D.7435 = nsize >> 3;
        if (D.7435 <= 31) goto <D.7436>; else goto <D.7437>;
        <D.7436>:
        {
          struct malloc_chunk * F;
          struct malloc_chunk * B;
          bindex_t I;

          F = next->fd;
          B = next->bk;
          D.7435 = nsize >> 3;
          I = (bindex_t) D.7435;
          if (F == B) goto <D.7438>; else goto <D.7439>;
          <D.7438>:
          D.7292 = _gm_.smallmap;
          I.66 = (int) I;
          D.7441 = 1 << I.66;
          D.7442 = ~D.7441;
          D.7443 = D.7292 & D.7442;
          _gm_.smallmap = D.7443;
          goto <D.7444>;
          <D.7439>:
          D.7451 = I << 1;
          D.7452 = &_gm_.smallbins[D.7451];
          D.7453 = D.7452 == F;
          D.7454 = (long int) D.7453;
          D.7455 = __builtin_expect (D.7454, 1);
          if (D.7455 != 0) goto <D.7448>; else goto <D.7456>;
          <D.7456>:
          D.7253 = _gm_.least_addr;
          D.7457 = D.7253 <= F;
          D.7458 = (long int) D.7457;
          D.7459 = __builtin_expect (D.7458, 1);
          if (D.7459 != 0) goto <D.7448>; else goto <D.7449>;
          <D.7448>:
          iftmp.67 = 1;
          goto <D.7450>;
          <D.7449>:
          iftmp.67 = 0;
          <D.7450>:
          if (iftmp.67 != 0) goto <D.7460>; else goto <D.7445>;
          <D.7460>:
          D.7451 = I << 1;
          D.7452 = &_gm_.smallbins[D.7451];
          D.7465 = D.7452 == B;
          D.7466 = (long int) D.7465;
          D.7467 = __builtin_expect (D.7466, 1);
          if (D.7467 != 0) goto <D.7462>; else goto <D.7468>;
          <D.7468>:
          D.7253 = _gm_.least_addr;
          D.7469 = D.7253 <= B;
          D.7470 = (long int) D.7469;
          D.7471 = __builtin_expect (D.7470, 1);
          if (D.7471 != 0) goto <D.7462>; else goto <D.7463>;
          <D.7462>:
          iftmp.68 = 1;
          goto <D.7464>;
          <D.7463>:
          iftmp.68 = 0;
          <D.7464>:
          if (iftmp.68 != 0) goto <D.7472>; else goto <D.7445>;
          <D.7472>:
          F->bk = B;
          B->fd = F;
          goto <D.7446>;
          <D.7445>:
          abort ();
          <D.7446>:
          <D.7444>:
        }
        goto <D.7473>;
        <D.7437>:
        {
          struct malloc_tree_chunk * TP;

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

            XP = TP->parent;
            D.7474 = TP->bk;
            if (D.7474 != TP) goto <D.7475>; else goto <D.7476>;
            <D.7475>:
            {
              struct malloc_tree_chunk * F;

              F = TP->fd;
              R = TP->bk;
              D.7253 = _gm_.least_addr;
              D.7477 = D.7253 <= F;
              D.7478 = (long int) D.7477;
              D.7479 = __builtin_expect (D.7478, 1);
              if (D.7479 != 0) goto <D.7480>; else goto <D.7481>;
              <D.7480>:
              F->bk = R;
              R->fd = F;
              goto <D.7482>;
              <D.7481>:
              abort ();
              <D.7482>:
            }
            goto <D.7483>;
            <D.7476>:
            {
              struct malloc_tree_chunk * * RP;

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

                goto <D.6100>;
                <D.6099>:
                RP = CP;
                R = *RP;
                <D.6100>:
                CP = &R->child[1];
                D.7487 = *CP;
                if (D.7487 != 0B) goto <D.6099>; else goto <D.7488>;
                <D.7488>:
                CP = &R->child[0];
                D.7487 = *CP;
                if (D.7487 != 0B) goto <D.6099>; else goto <D.6101>;
                <D.6101>:
                D.7253 = _gm_.least_addr;
                D.7489 = D.7253 <= RP;
                D.7490 = (long int) D.7489;
                D.7491 = __builtin_expect (D.7490, 1);
                if (D.7491 != 0) goto <D.7492>; else goto <D.7493>;
                <D.7492>:
                *RP = 0B;
                goto <D.7494>;
                <D.7493>:
                abort ();
                <D.7494>:
              }
              <D.7485>:
            }
            <D.7483>:
            if (XP != 0B) goto <D.7495>; else goto <D.7496>;
            <D.7495>:
            {
              struct malloc_tree_chunk * * H;

              D.7497 = TP->index;
              H = &_gm_.treebins[D.7497];
              D.7498 = *H;
              if (D.7498 == TP) goto <D.7499>; else goto <D.7500>;
              <D.7499>:
              *H = R;
              D.7498 = *H;
              if (D.7498 == 0B) goto <D.7501>; else goto <D.7502>;
              <D.7501>:
              D.7356 = _gm_.treemap;
              D.7497 = TP->index;
              D.7503 = (int) D.7497;
              D.7504 = 1 << D.7503;
              D.7505 = ~D.7504;
              D.7506 = D.7356 & D.7505;
              _gm_.treemap = D.7506;
              <D.7502>:
              goto <D.7507>;
              <D.7500>:
              D.7253 = _gm_.least_addr;
              D.7508 = D.7253 <= XP;
              D.7509 = (long int) D.7508;
              D.7510 = __builtin_expect (D.7509, 1);
              if (D.7510 != 0) goto <D.7511>; else goto <D.7512>;
              <D.7511>:
              D.7513 = XP->child[0];
              if (D.7513 == TP) goto <D.7514>; else goto <D.7515>;
              <D.7514>:
              XP->child[0] = R;
              goto <D.7516>;
              <D.7515>:
              XP->child[1] = R;
              <D.7516>:
              goto <D.7517>;
              <D.7512>:
              abort ();
              <D.7517>:
              <D.7507>:
              if (R != 0B) goto <D.7518>; else goto <D.7519>;
              <D.7518>:
              D.7253 = _gm_.least_addr;
              D.7520 = D.7253 <= R;
              D.7521 = (long int) D.7520;
              D.7522 = __builtin_expect (D.7521, 1);
              if (D.7522 != 0) goto <D.7523>; else goto <D.7524>;
              <D.7523>:
              {
                struct malloc_tree_chunk * C0;
                struct malloc_tree_chunk * C1;

                R->parent = XP;
                C0 = TP->child[0];
                if (C0 != 0B) goto <D.7525>; else goto <D.7526>;
                <D.7525>:
                D.7253 = _gm_.least_addr;
                D.7527 = D.7253 <= C0;
                D.7528 = (long int) D.7527;
                D.7529 = __builtin_expect (D.7528, 1);
                if (D.7529 != 0) goto <D.7530>; else goto <D.7531>;
                <D.7530>:
                R->child[0] = C0;
                C0->parent = R;
                goto <D.7532>;
                <D.7531>:
                abort ();
                <D.7532>:
                <D.7526>:
                C1 = TP->child[1];
                if (C1 != 0B) goto <D.7533>; else goto <D.7534>;
                <D.7533>:
                D.7253 = _gm_.least_addr;
                D.7535 = D.7253 <= C1;
                D.7536 = (long int) D.7535;
                D.7537 = __builtin_expect (D.7536, 1);
                if (D.7537 != 0) goto <D.7538>; else goto <D.7539>;
                <D.7538>:
                R->child[1] = C1;
                C1->parent = R;
                goto <D.7540>;
                <D.7539>:
                abort ();
                <D.7540>:
                <D.7534>:
              }
              goto <D.7541>;
              <D.7524>:
              abort ();
              <D.7541>:
              <D.7519>:
            }
            <D.7496>:
          }
        }
        <D.7473>:
        D.7402 = psize | 1;
        p->head = D.7402;
        D.7403 = p + psize;
        D.7403->prev_foot = psize;
        D.7284 = _gm_.dv;
        if (D.7284 == p) goto <D.7542>; else goto <D.7543>;
        <D.7542>:
        _gm_.dvsize = psize;
        goto postaction;
        <D.7543>:
      }
      goto <D.7544>;
      <D.7417>:
      D.7397 = next->head;
      D.7401 = D.7397 & 18446744073709551614;
      next->head = D.7401;
      D.7402 = psize | 1;
      p->head = D.7402;
      D.7403 = p + psize;
      D.7403->prev_foot = psize;
      <D.7544>:
      D.7545 = psize >> 3;
      if (D.7545 <= 31) goto <D.7546>; else goto <D.7547>;
      <D.7546>:
      {
        bindex_t I;
        struct malloc_chunk * B;
        struct malloc_chunk * F;

        D.7545 = psize >> 3;
        I = (bindex_t) D.7545;
        D.7548 = I << 1;
        B = &_gm_.smallbins[D.7548];
        F = B;
        D.7292 = _gm_.smallmap;
        I.69 = (int) I;
        D.7550 = 1 << I.69;
        D.7551 = D.7292 & D.7550;
        if (D.7551 == 0) goto <D.7552>; else goto <D.7553>;
        <D.7552>:
        D.7292 = _gm_.smallmap;
        I.69 = (int) I;
        D.7550 = 1 << I.69;
        D.7554 = D.7292 | D.7550;
        _gm_.smallmap = D.7554;
        goto <D.7555>;
        <D.7553>:
        D.7556 = B->fd;
        D.7253 = _gm_.least_addr;
        D.7557 = D.7556 >= D.7253;
        D.7558 = (long int) D.7557;
        D.7559 = __builtin_expect (D.7558, 1);
        if (D.7559 != 0) goto <D.7560>; else goto <D.7561>;
        <D.7560>:
        F = B->fd;
        goto <D.7562>;
        <D.7561>:
        abort ();
        <D.7562>:
        <D.7555>:
        B->fd = p;
        F->bk = p;
        p->fd = F;
        p->bk = B;
      }
      goto <D.7563>;
      <D.7547>:
      {
        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.7564>; else goto <D.7565>;
            <D.7564>:
            I = 0;
            goto <D.7566>;
            <D.7565>:
            if (X > 65535) goto <D.7567>; else goto <D.7568>;
            <D.7567>:
            I = 31;
            goto <D.7569>;
            <D.7568>:
            {
              unsigned int Y;
              unsigned int N;
              unsigned int K;

              Y = (unsigned int) X;
              D.7570 = Y + 4294967040;
              D.7571 = D.7570 >> 16;
              N = D.7571 & 8;
              N.70 = (int) N;
              Y = Y << N.70;
              D.7573 = Y + 4294963200;
              D.7574 = D.7573 >> 16;
              K = D.7574 & 4;
              N = N + K;
              K.71 = (int) K;
              Y = Y << K.71;
              D.7576 = Y + 4294950912;
              D.7577 = D.7576 >> 16;
              K = D.7577 & 2;
              K.72 = K;
              N = K.72 + N;
              K.71 = (int) K;
              Y = Y << K.71;
              D.7579 = Y >> 15;
              D.7580 = D.7579 - N;
              K = D.7580 + 14;
              D.7581 = K << 1;
              D.7582 = K + 7;
              D.7583 = (int) D.7582;
              D.7584 = psize >> D.7583;
              D.7585 = (unsigned int) D.7584;
              D.7586 = D.7585 & 1;
              I = D.7581 + D.7586;
            }
            <D.7569>:
            <D.7566>:
          }
          H = &_gm_.treebins[I];
          TP->index = I;
          TP->child[1] = 0B;
          D.7587 = TP->child[1];
          TP->child[0] = D.7587;
          D.7356 = _gm_.treemap;
          I.73 = (int) I;
          D.7589 = 1 << I.73;
          D.7590 = D.7356 & D.7589;
          if (D.7590 == 0) goto <D.7591>; else goto <D.7592>;
          <D.7591>:
          D.7356 = _gm_.treemap;
          I.73 = (int) I;
          D.7589 = 1 << I.73;
          D.7593 = D.7356 | D.7589;
          _gm_.treemap = D.7593;
          *H = TP;
          TP->parent = H;
          TP->bk = TP;
          D.7594 = TP->bk;
          TP->fd = D.7594;
          goto <D.7595>;
          <D.7592>:
          {
            struct malloc_tree_chunk * T;
            size_t K;

            T = *H;
            if (I != 31) goto <D.7597>; else goto <D.7598>;
            <D.7597>:
            D.7599 = I >> 1;
            D.7600 = D.7599 + 6;
            D.7601 = (long unsigned int) D.7600;
            D.7602 = 63 - D.7601;
            iftmp.74 = (int) D.7602;
            goto <D.7603>;
            <D.7598>:
            iftmp.74 = 0;
            <D.7603>:
            K = psize << iftmp.74;
            <D.6120>:
            D.7604 = T->head;
            D.7605 = D.7604 & 18446744073709551612;
            if (D.7605 != psize) goto <D.7606>; else goto <D.7607>;
            <D.7606>:
            {
              struct malloc_tree_chunk * * C;

              D.7608 = K >> 63;
              C = &T->child[D.7608];
              K = K << 1;
              D.7609 = *C;
              if (D.7609 != 0B) goto <D.7610>; else goto <D.7611>;
              <D.7610>:
              T = *C;
              goto <D.7612>;
              <D.7611>:
              D.7253 = _gm_.least_addr;
              D.7613 = D.7253 <= C;
              D.7614 = (long int) D.7613;
              D.7615 = __builtin_expect (D.7614, 1);
              if (D.7615 != 0) goto <D.7616>; else goto <D.7617>;
              <D.7616>:
              *C = TP;
              TP->parent = T;
              TP->bk = TP;
              D.7594 = TP->bk;
              TP->fd = D.7594;
              goto <D.6118>;
              <D.7617>:
              abort ();
              <D.7612>:
            }
            goto <D.7618>;
            <D.7607>:
            {
              struct malloc_tree_chunk * F;

              F = T->fd;
              D.7253 = _gm_.least_addr;
              D.7620 = D.7253 <= T;
              D.7621 = (long int) D.7620;
              D.7622 = __builtin_expect (D.7621, 1);
              if (D.7622 != 0) goto <D.7623>; else goto <D.7619>;
              <D.7623>:
              D.7253 = _gm_.least_addr;
              D.7624 = D.7253 <= F;
              D.7625 = (long int) D.7624;
              D.7626 = __builtin_expect (D.7625, 1);
              if (D.7626 != 0) goto <D.7627>; else goto <D.7619>;
              <D.7627>:
              F->bk = TP;
              D.7628 = F->bk;
              T->fd = D.7628;
              TP->fd = F;
              TP->bk = T;
              TP->parent = 0B;
              goto <D.6118>;
              <D.7619>:
              abort ();
            }
            <D.7618>:
            goto <D.6120>;
            <D.6118>:
          }
          <D.7595>:
        }
      }
      <D.7563>:
      goto postaction;
      <D.7414>:
      <D.7408>:
    }
    <D.7265>:
    <D.7258>:
    erroraction:
    abort ();
    postaction:
    D.7250 = _gm_.mflags;
    D.7251 = D.7250 & 2;
    if (D.7251 != 0) goto <D.7629>; else goto <D.7630>;
    <D.7629>:
    pthread_mutex_unlock (&_gm_.mutex);
    <D.7630>:
    <D.7246>:
  }
  <D.7242>:
}


sys_trim (struct malloc_state * m, size_t pad)
{
  struct malloc_chunk * D.7633;
  long unsigned int D.7636;
  long unsigned int D.7639;
  long unsigned int D.7640;
  long unsigned int D.7641;
  long unsigned int D.7642;
  long unsigned int D.7643;
  unsigned int D.7644;
  unsigned int D.7645;
  long unsigned int D.7648;
  long unsigned int D.7649;
  long unsigned int D.7652;
  int D.7655;
  char * D.7660;
  void * D.7661;
  void * D.7663;
  int D.7664;
  char * D.7670;
  long int old_br.75;
  long int new_br.76;
  long int D.7679;
  long unsigned int D.7682;
  long unsigned int D.7683;
  long unsigned int D.7684;
  long unsigned int D.7685;
  long unsigned int D.7688;
  int D.7691;
  _Bool D.7692;
  size_t released;

  released = 0;
  if (pad <= 18446744073709551487) goto <D.7631>; else goto <D.7632>;
  <D.7631>:
  D.7633 = m->top;
  if (D.7633 != 0B) goto <D.7634>; else goto <D.7635>;
  <D.7634>:
  pad = pad + 72;
  D.7636 = m->topsize;
  if (D.7636 > pad) goto <D.7637>; else goto <D.7638>;
  <D.7637>:
  {
    size_t unit;
    size_t extra;
    struct malloc_segment * sp;

    unit = mparams.granularity;
    D.7636 = m->topsize;
    D.7639 = D.7636 - pad;
    D.7640 = D.7639 + unit;
    D.7641 = D.7640 + 18446744073709551615;
    D.7642 = D.7641 / unit;
    D.7643 = D.7642 + 18446744073709551615;
    extra = D.7643 * unit;
    D.7633 = m->top;
    sp = segment_holding (m, D.7633);
    D.7644 = sp->sflags;
    D.7645 = D.7644 & 8;
    if (D.7645 == 0) goto <D.7646>; else goto <D.7647>;
    <D.7646>:
    D.7644 = sp->sflags;
    D.7648 = (long unsigned int) D.7644;
    D.7649 = D.7648 & 1;
    if (D.7649 != 0) goto <D.7650>; else goto <D.7651>;
    <D.7650>:
    D.7652 = sp->size;
    if (D.7652 >= extra) goto <D.7653>; else goto <D.7654>;
    <D.7653>:
    D.7655 = has_segment_link (m, sp);
    if (D.7655 == 0) goto <D.7656>; else goto <D.7657>;
    <D.7656>:
    {
      size_t newsize;

      D.7652 = sp->size;
      newsize = D.7652 - extra;
      D.7660 = sp->base;
      D.7652 = sp->size;
      D.7661 = mremap (D.7660, D.7652, newsize, 0);
      if (D.7661 != -1B) goto <D.7658>; else goto <D.7662>;
      <D.7662>:
      D.7660 = sp->base;
      D.7663 = D.7660 + newsize;
      D.7664 = munmap (D.7663, extra);
      if (D.7664 == 0) goto <D.7658>; else goto <D.7659>;
      <D.7658>:
      released = extra;
      <D.7659>:
    }
    <D.7657>:
    <D.7654>:
    goto <D.7665>;
    <D.7651>:
    if (0 != 0) goto <D.7666>; else goto <D.7667>;
    <D.7666>:
    if (extra > 9223372036854775806) goto <D.7668>; else goto <D.7669>;
    <D.7668>:
    extra = 9223372036854775808 - unit;
    <D.7669>:
    {
      char * old_br;

      old_br = -1B;
      D.7660 = sp->base;
      D.7652 = sp->size;
      D.7670 = D.7660 + D.7652;
      if (D.7670 == old_br) goto <D.7671>; else goto <D.7672>;
      <D.7671>:
      {
        char * rel_br;
        char * new_br;

        rel_br = -1B;
        new_br = -1B;
        if (rel_br != -1B) goto <D.7673>; else goto <D.7674>;
        <D.7673>:
        if (new_br < old_br) goto <D.7675>; else goto <D.7676>;
        <D.7675>:
        old_br.75 = (long int) old_br;
        new_br.76 = (long int) new_br;
        D.7679 = old_br.75 - new_br.76;
        released = (size_t) D.7679;
        <D.7676>:
        <D.7674>:
      }
      <D.7672>:
    }
    <D.7667>:
    <D.7665>:
    <D.7647>:
    if (released != 0) goto <D.7680>; else goto <D.7681>;
    <D.7680>:
    D.7652 = sp->size;
    D.7682 = D.7652 - released;
    sp->size = D.7682;
    D.7683 = m->footprint;
    D.7684 = D.7683 - released;
    m->footprint = D.7684;
    D.7633 = m->top;
    D.7636 = m->topsize;
    D.7685 = D.7636 - released;
    init_top (m, D.7633, D.7685);
    <D.7681>:
  }
  <D.7638>:
  if (1 != 0) goto <D.7686>; else goto <D.7687>;
  <D.7686>:
  D.7688 = release_unused_segments (m);
  released = D.7688 + released;
  <D.7687>:
  if (released == 0) goto <D.7689>; else goto <D.7690>;
  <D.7689>:
  m->trim_check = 18446744073709551615;
  <D.7690>:
  <D.7635>:
  <D.7632>:
  D.7692 = released != 0;
  D.7691 = (int) D.7692;
  return D.7691;
}


has_segment_link (struct malloc_state * m, struct malloc_segment * ss)
{
  char * D.7694;
  long unsigned int D.7697;
  char * D.7698;
  int D.7701;
  struct malloc_segment * sp;

  sp = &m->seg;
  <D.5719>:
  D.7694 = ss->base;
  if (D.7694 <= sp) goto <D.7695>; else goto <D.7696>;
  <D.7695>:
  D.7694 = ss->base;
  D.7697 = ss->size;
  D.7698 = D.7694 + D.7697;
  if (D.7698 > sp) goto <D.7699>; else goto <D.7700>;
  <D.7699>:
  D.7701 = 1;
  return D.7701;
  <D.7700>:
  <D.7696>:
  sp = sp->next;
  if (sp == 0B) goto <D.7702>; else goto <D.7703>;
  <D.7702>:
  D.7701 = 0;
  return D.7701;
  <D.7703>:
  goto <D.5719>;
}


release_unused_segments (struct malloc_state * m)
{
  unsigned int D.7705;
  long unsigned int D.7706;
  long unsigned int D.7707;
  unsigned int D.7710;
  sizetype iftmp.77;
  void * D.7714;
  long unsigned int D.7715;
  long unsigned int D.7716;
  long unsigned int D.7719;
  long unsigned int D.7721;
  long unsigned int D.7722;
  char * D.7725;
  sizetype D.7726;
  char * D.7727;
  struct malloc_chunk * D.7730;
  struct malloc_tree_chunk * D.7734;
  char * D.7737;
  _Bool D.7738;
  long int D.7739;
  long int D.7740;
  struct malloc_tree_chunk * D.7748;
  _Bool D.7750;
  long int D.7751;
  long int D.7752;
  unsigned int D.7758;
  struct malloc_tree_chunk * D.7759;
  unsigned int D.7764;
  int D.7765;
  unsigned int D.7766;
  unsigned int D.7767;
  unsigned int D.7768;
  _Bool D.7770;
  long int D.7771;
  long int D.7772;
  struct malloc_tree_chunk * D.7775;
  _Bool D.7782;
  long int D.7783;
  long int D.7784;
  _Bool D.7789;
  long int D.7790;
  long int D.7791;
  _Bool D.7797;
  long int D.7798;
  long int D.7799;
  int D.7804;
  long unsigned int D.7807;
  long unsigned int D.7808;
  unsigned int D.7816;
  unsigned int D.7817;
  int N.78;
  unsigned int D.7819;
  unsigned int D.7820;
  int K.79;
  unsigned int D.7822;
  unsigned int D.7823;
  unsigned int K.80;
  unsigned int D.7825;
  unsigned int D.7826;
  unsigned int D.7827;
  unsigned int D.7828;
  int D.7829;
  long unsigned int D.7830;
  unsigned int D.7831;
  unsigned int D.7832;
  struct malloc_tree_chunk * D.7833;
  int I.81;
  unsigned int D.7835;
  unsigned int D.7836;
  unsigned int D.7839;
  int iftmp.82;
  unsigned int D.7844;
  unsigned int D.7845;
  long unsigned int D.7846;
  long unsigned int D.7847;
  long unsigned int D.7849;
  long unsigned int D.7850;
  long unsigned int D.7853;
  struct malloc_tree_chunk * D.7854;
  _Bool D.7858;
  long int D.7859;
  long int D.7860;
  _Bool D.7865;
  long int D.7866;
  long int D.7867;
  _Bool D.7869;
  long int D.7870;
  long int D.7871;
  struct malloc_tree_chunk * D.7873;
  size_t D.7874;
  size_t released;
  struct malloc_segment * pred;
  struct malloc_segment * sp;

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

    base = sp->base;
    size = sp->size;
    next = sp->next;
    D.7705 = sp->sflags;
    D.7706 = (long unsigned int) D.7705;
    D.7707 = D.7706 & 1;
    if (D.7707 != 0) goto <D.7708>; else goto <D.7709>;
    <D.7708>:
    D.7705 = sp->sflags;
    D.7710 = D.7705 & 8;
    if (D.7710 == 0) goto <D.7711>; else goto <D.7712>;
    <D.7711>:
    {
      struct malloc_chunk * p;
      size_t psize;

      D.7714 = base + 16;
      D.7715 = (long unsigned int) D.7714;
      D.7716 = D.7715 & 7;
      if (D.7716 != 0) goto <D.7717>; else goto <D.7718>;
      <D.7717>:
      D.7714 = base + 16;
      D.7715 = (long unsigned int) D.7714;
      D.7719 = -D.7715;
      iftmp.77 = D.7719 & 7;
      goto <D.7720>;
      <D.7718>:
      iftmp.77 = 0;
      <D.7720>:
      p = base + iftmp.77;
      D.7721 = p->head;
      psize = D.7721 & 18446744073709551612;
      D.7721 = p->head;
      D.7722 = D.7721 & 2;
      if (D.7722 == 0) goto <D.7723>; else goto <D.7724>;
      <D.7723>:
      D.7725 = p + psize;
      D.7726 = size + 18446744073709551544;
      D.7727 = base + D.7726;
      if (D.7725 >= D.7727) goto <D.7728>; else goto <D.7729>;
      <D.7728>:
      {
        struct malloc_tree_chunk * tp;

        tp = p;
        D.7730 = m->dv;
        if (D.7730 == p) goto <D.7731>; else goto <D.7732>;
        <D.7731>:
        m->dv = 0B;
        m->dvsize = 0;
        goto <D.7733>;
        <D.7732>:
        {
          struct malloc_tree_chunk * XP;
          struct malloc_tree_chunk * R;

          XP = tp->parent;
          D.7734 = tp->bk;
          if (D.7734 != tp) goto <D.7735>; else goto <D.7736>;
          <D.7735>:
          {
            struct malloc_tree_chunk * F;

            F = tp->fd;
            R = tp->bk;
            D.7737 = m->least_addr;
            D.7738 = D.7737 <= F;
            D.7739 = (long int) D.7738;
            D.7740 = __builtin_expect (D.7739, 1);
            if (D.7740 != 0) goto <D.7741>; else goto <D.7742>;
            <D.7741>:
            F->bk = R;
            R->fd = F;
            goto <D.7743>;
            <D.7742>:
            abort ();
            <D.7743>:
          }
          goto <D.7744>;
          <D.7736>:
          {
            struct malloc_tree_chunk * * RP;

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

              goto <D.5884>;
              <D.5883>:
              RP = CP;
              R = *RP;
              <D.5884>:
              CP = &R->child[1];
              D.7748 = *CP;
              if (D.7748 != 0B) goto <D.5883>; else goto <D.7749>;
              <D.7749>:
              CP = &R->child[0];
              D.7748 = *CP;
              if (D.7748 != 0B) goto <D.5883>; else goto <D.5885>;
              <D.5885>:
              D.7737 = m->least_addr;
              D.7750 = D.7737 <= RP;
              D.7751 = (long int) D.7750;
              D.7752 = __builtin_expect (D.7751, 1);
              if (D.7752 != 0) goto <D.7753>; else goto <D.7754>;
              <D.7753>:
              *RP = 0B;
              goto <D.7755>;
              <D.7754>:
              abort ();
              <D.7755>:
            }
            <D.7746>:
          }
          <D.7744>:
          if (XP != 0B) goto <D.7756>; else goto <D.7757>;
          <D.7756>:
          {
            struct malloc_tree_chunk * * H;

            D.7758 = tp->index;
            H = &m->treebins[D.7758];
            D.7759 = *H;
            if (D.7759 == tp) goto <D.7760>; else goto <D.7761>;
            <D.7760>:
            *H = R;
            D.7759 = *H;
            if (D.7759 == 0B) goto <D.7762>; else goto <D.7763>;
            <D.7762>:
            D.7764 = m->treemap;
            D.7758 = tp->index;
            D.7765 = (int) D.7758;
            D.7766 = 1 << D.7765;
            D.7767 = ~D.7766;
            D.7768 = D.7764 & D.7767;
            m->treemap = D.7768;
            <D.7763>:
            goto <D.7769>;
            <D.7761>:
            D.7737 = m->least_addr;
            D.7770 = D.7737 <= XP;
            D.7771 = (long int) D.7770;
            D.7772 = __builtin_expect (D.7771, 1);
            if (D.7772 != 0) goto <D.7773>; else goto <D.7774>;
            <D.7773>:
            D.7775 = XP->child[0];
            if (D.7775 == tp) goto <D.7776>; else goto <D.7777>;
            <D.7776>:
            XP->child[0] = R;
            goto <D.7778>;
            <D.7777>:
            XP->child[1] = R;
            <D.7778>:
            goto <D.7779>;
            <D.7774>:
            abort ();
            <D.7779>:
            <D.7769>:
            if (R != 0B) goto <D.7780>; else goto <D.7781>;
            <D.7780>:
            D.7737 = m->least_addr;
            D.7782 = D.7737 <= R;
            D.7783 = (long int) D.7782;
            D.7784 = __builtin_expect (D.7783, 1);
            if (D.7784 != 0) goto <D.7785>; else goto <D.7786>;
            <D.7785>:
            {
              struct malloc_tree_chunk * C0;
              struct malloc_tree_chunk * C1;

              R->parent = XP;
              C0 = tp->child[0];
              if (C0 != 0B) goto <D.7787>; else goto <D.7788>;
              <D.7787>:
              D.7737 = m->least_addr;
              D.7789 = D.7737 <= C0;
              D.7790 = (long int) D.7789;
              D.7791 = __builtin_expect (D.7790, 1);
              if (D.7791 != 0) goto <D.7792>; else goto <D.7793>;
              <D.7792>:
              R->child[0] = C0;
              C0->parent = R;
              goto <D.7794>;
              <D.7793>:
              abort ();
              <D.7794>:
              <D.7788>:
              C1 = tp->child[1];
              if (C1 != 0B) goto <D.7795>; else goto <D.7796>;
              <D.7795>:
              D.7737 = m->least_addr;
              D.7797 = D.7737 <= C1;
              D.7798 = (long int) D.7797;
              D.7799 = __builtin_expect (D.7798, 1);
              if (D.7799 != 0) goto <D.7800>; else goto <D.7801>;
              <D.7800>:
              R->child[1] = C1;
              C1->parent = R;
              goto <D.7802>;
              <D.7801>:
              abort ();
              <D.7802>:
              <D.7796>:
            }
            goto <D.7803>;
            <D.7786>:
            abort ();
            <D.7803>:
            <D.7781>:
          }
          <D.7757>:
        }
        <D.7733>:
        D.7804 = munmap (base, size);
        if (D.7804 == 0) goto <D.7805>; else goto <D.7806>;
        <D.7805>:
        released = released + size;
        D.7807 = m->footprint;
        D.7808 = D.7807 - size;
        m->footprint = D.7808;
        sp = pred;
        sp->next = next;
        goto <D.7809>;
        <D.7806>:
        {
          struct malloc_tree_chunk * * H;
          bindex_t I;

          {
            size_t X;

            X = psize >> 8;
            if (X == 0) goto <D.7810>; else goto <D.7811>;
            <D.7810>:
            I = 0;
            goto <D.7812>;
            <D.7811>:
            if (X > 65535) goto <D.7813>; else goto <D.7814>;
            <D.7813>:
            I = 31;
            goto <D.7815>;
            <D.7814>:
            {
              unsigned int Y;
              unsigned int N;
              unsigned int K;

              Y = (unsigned int) X;
              D.7816 = Y + 4294967040;
              D.7817 = D.7816 >> 16;
              N = D.7817 & 8;
              N.78 = (int) N;
              Y = Y << N.78;
              D.7819 = Y + 4294963200;
              D.7820 = D.7819 >> 16;
              K = D.7820 & 4;
              N = N + K;
              K.79 = (int) K;
              Y = Y << K.79;
              D.7822 = Y + 4294950912;
              D.7823 = D.7822 >> 16;
              K = D.7823 & 2;
              K.80 = K;
              N = K.80 + N;
              K.79 = (int) K;
              Y = Y << K.79;
              D.7825 = Y >> 15;
              D.7826 = D.7825 - N;
              K = D.7826 + 14;
              D.7827 = K << 1;
              D.7828 = K + 7;
              D.7829 = (int) D.7828;
              D.7830 = psize >> D.7829;
              D.7831 = (unsigned int) D.7830;
              D.7832 = D.7831 & 1;
              I = D.7827 + D.7832;
            }
            <D.7815>:
            <D.7812>:
          }
          H = &m->treebins[I];
          tp->index = I;
          tp->child[1] = 0B;
          D.7833 = tp->child[1];
          tp->child[0] = D.7833;
          D.7764 = m->treemap;
          I.81 = (int) I;
          D.7835 = 1 << I.81;
          D.7836 = D.7764 & D.7835;
          if (D.7836 == 0) goto <D.7837>; else goto <D.7838>;
          <D.7837>:
          D.7764 = m->treemap;
          I.81 = (int) I;
          D.7835 = 1 << I.81;
          D.7839 = D.7764 | D.7835;
          m->treemap = D.7839;
          *H = tp;
          tp->parent = H;
          tp->bk = tp;
          D.7734 = tp->bk;
          tp->fd = D.7734;
          goto <D.7840>;
          <D.7838>:
          {
            struct malloc_tree_chunk * T;
            size_t K;

            T = *H;
            if (I != 31) goto <D.7842>; else goto <D.7843>;
            <D.7842>:
            D.7844 = I >> 1;
            D.7845 = D.7844 + 6;
            D.7846 = (long unsigned int) D.7845;
            D.7847 = 63 - D.7846;
            iftmp.82 = (int) D.7847;
            goto <D.7848>;
            <D.7843>:
            iftmp.82 = 0;
            <D.7848>:
            K = psize << iftmp.82;
            <D.5900>:
            D.7849 = T->head;
            D.7850 = D.7849 & 18446744073709551612;
            if (D.7850 != psize) goto <D.7851>; else goto <D.7852>;
            <D.7851>:
            {
              struct malloc_tree_chunk * * C;

              D.7853 = K >> 63;
              C = &T->child[D.7853];
              K = K << 1;
              D.7854 = *C;
              if (D.7854 != 0B) goto <D.7855>; else goto <D.7856>;
              <D.7855>:
              T = *C;
              goto <D.7857>;
              <D.7856>:
              D.7737 = m->least_addr;
              D.7858 = D.7737 <= C;
              D.7859 = (long int) D.7858;
              D.7860 = __builtin_expect (D.7859, 1);
              if (D.7860 != 0) goto <D.7861>; else goto <D.7862>;
              <D.7861>:
              *C = tp;
              tp->parent = T;
              tp->bk = tp;
              D.7734 = tp->bk;
              tp->fd = D.7734;
              goto <D.5898>;
              <D.7862>:
              abort ();
              <D.7857>:
            }
            goto <D.7863>;
            <D.7852>:
            {
              struct malloc_tree_chunk * F;

              F = T->fd;
              D.7737 = m->least_addr;
              D.7865 = D.7737 <= T;
              D.7866 = (long int) D.7865;
              D.7867 = __builtin_expect (D.7866, 1);
              if (D.7867 != 0) goto <D.7868>; else goto <D.7864>;
              <D.7868>:
              D.7737 = m->least_addr;
              D.7869 = D.7737 <= F;
              D.7870 = (long int) D.7869;
              D.7871 = __builtin_expect (D.7870, 1);
              if (D.7871 != 0) goto <D.7872>; else goto <D.7864>;
              <D.7872>:
              F->bk = tp;
              D.7873 = F->bk;
              T->fd = D.7873;
              tp->fd = F;
              tp->bk = T;
              tp->parent = 0B;
              goto <D.5898>;
              <D.7864>:
              abort ();
            }
            <D.7863>:
            goto <D.5900>;
            <D.5898>:
          }
          <D.7840>:
        }
        <D.7809>:
      }
      <D.7729>:
      <D.7724>:
    }
    <D.7712>:
    <D.7709>:
    pred = sp;
    sp = next;
  }
  <D.5902>:
  if (sp != 0B) goto <D.5901>; else goto <D.5903>;
  <D.5903>:
  D.7874 = released;
  return D.7874;
}


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

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


internal_memalign (struct malloc_state * m, size_t alignment, size_t bytes)
{
  void * D.7880;
  long unsigned int D.7883;
  long unsigned int D.7884;
  long unsigned int D.7887;
  int * D.7892;
  long unsigned int iftmp.83;
  long unsigned int D.7897;
  long unsigned int D.7899;
  long unsigned int D.7905;
  int D.7907;
  unsigned int D.7908;
  unsigned int D.7909;
  union pthread_mutex_t * D.7910;
  int D.7911;
  long unsigned int mem.84;
  long unsigned int D.7915;
  sizetype D.7918;
  char * D.7919;
  long unsigned int D.7920;
  long unsigned int D.7921;
  long unsigned int D.7922;
  sizetype D.7923;
  char * iftmp.85;
  long int br.86;
  long int p.87;
  long int D.7927;
  long unsigned int D.7928;
  long int pos.88;
  long int D.7933;
  long unsigned int D.7934;
  long unsigned int D.7935;
  long unsigned int D.7938;
  long unsigned int D.7940;
  long unsigned int D.7941;
  long unsigned int D.7943;
  long unsigned int D.7944;
  long unsigned int D.7945;
  long unsigned int D.7946;
  long unsigned int D.7947;
  long unsigned int D.7948;
  struct malloc_chunk * D.7949;
  long unsigned int D.7950;
  long unsigned int D.7951;
  long unsigned int D.7952;
  long unsigned int D.7953;
  struct malloc_chunk * D.7954;
  long unsigned int D.7955;
  long unsigned int D.7956;
  long unsigned int D.7960;
  long unsigned int D.7963;
  long unsigned int D.7964;
  struct malloc_chunk * D.7965;
  long unsigned int D.7966;
  long unsigned int D.7967;
  long unsigned int D.7968;
  long unsigned int D.7969;
  long unsigned int D.7970;
  long unsigned int D.7971;
  struct malloc_chunk * D.7972;
  long unsigned int D.7973;
  long unsigned int D.7974;

  if (alignment <= 8) goto <D.7878>; else goto <D.7879>;
  <D.7878>:
  D.7880 = dlmalloc (bytes);
  return D.7880;
  <D.7879>:
  if (alignment <= 31) goto <D.7881>; else goto <D.7882>;
  <D.7881>:
  alignment = 32;
  <D.7882>:
  D.7883 = alignment + 18446744073709551615;
  D.7884 = D.7883 & alignment;
  if (D.7884 != 0) goto <D.7885>; else goto <D.7886>;
  <D.7885>:
  {
    size_t a;

    a = 16;
    goto <D.6012>;
    <D.6011>:
    a = a << 1;
    <D.6012>:
    if (a < alignment) goto <D.6011>; else goto <D.6013>;
    <D.6013>:
    alignment = a;
  }
  <D.7886>:
  D.7887 = 18446744073709551488 - alignment;
  if (D.7887 <= bytes) goto <D.7888>; else goto <D.7889>;
  <D.7888>:
  if (m != 0B) goto <D.7890>; else goto <D.7891>;
  <D.7890>:
  D.7892 = __errno_location ();
  *D.7892 = 12;
  <D.7891>:
  goto <D.7893>;
  <D.7889>:
  {
    size_t nb;
    size_t req;
    char * mem;

    if (bytes > 22) goto <D.7895>; else goto <D.7896>;
    <D.7895>:
    D.7897 = bytes + 15;
    iftmp.83 = D.7897 & 18446744073709551608;
    goto <D.7898>;
    <D.7896>:
    iftmp.83 = 32;
    <D.7898>:
    nb = iftmp.83;
    D.7899 = nb + alignment;
    req = D.7899 + 24;
    mem = dlmalloc (req);
    if (mem != 0B) goto <D.7900>; else goto <D.7901>;
    <D.7900>:
    {
      void * leader;
      void * trailer;
      struct malloc_chunk * p;

      leader = 0B;
      trailer = 0B;
      p = mem + 18446744073709551600;
      D.7905 = mparams.page_size;
      if (D.7905 == 0) goto <D.7906>; else goto <D.7902>;
      <D.7906>:
      D.7907 = init_mparams ();
      if (D.7907 != 0) goto <D.7903>; else goto <D.7902>;
      <D.7902>:
      D.7908 = m->mflags;
      D.7909 = D.7908 & 2;
      if (D.7909 != 0) goto <D.7903>; else goto <D.7904>;
      <D.7903>:
      D.7910 = &m->mutex;
      D.7911 = pthread_mutex_lock (D.7910);
      if (D.7911 != 0) goto <D.7912>; else goto <D.7913>;
      <D.7912>:
      D.7880 = 0B;
      return D.7880;
      <D.7913>:
      <D.7904>:
      mem.84 = (long unsigned int) mem;
      D.7915 = mem.84 % alignment;
      if (D.7915 != 0) goto <D.7916>; else goto <D.7917>;
      <D.7916>:
      {
        char * br;
        char * pos;
        struct malloc_chunk * newp;
        size_t leadsize;
        size_t newsize;

        D.7918 = alignment + 18446744073709551615;
        D.7919 = mem + D.7918;
        D.7920 = (long unsigned int) D.7919;
        D.7921 = -alignment;
        D.7922 = D.7920 & D.7921;
        D.7923 = D.7922 + 18446744073709551600;
        br = (char *) D.7923;
        br.86 = (long int) br;
        p.87 = (long int) p;
        D.7927 = br.86 - p.87;
        D.7928 = (long unsigned int) D.7927;
        if (D.7928 <= 31) goto <D.7929>; else goto <D.7930>;
        <D.7929>:
        iftmp.85 = br + alignment;
        goto <D.7931>;
        <D.7930>:
        iftmp.85 = br;
        <D.7931>:
        pos = iftmp.85;
        newp = pos;
        pos.88 = (long int) pos;
        p.87 = (long int) p;
        D.7933 = pos.88 - p.87;
        leadsize = (size_t) D.7933;
        D.7934 = p->head;
        D.7935 = D.7934 & 18446744073709551612;
        newsize = D.7935 - leadsize;
        D.7934 = p->head;
        D.7938 = D.7934 & 1;
        if (D.7938 == 0) goto <D.7939>; else goto <D.7936>;
        <D.7939>:
        D.7940 = p->prev_foot;
        D.7941 = D.7940 & 1;
        if (D.7941 != 0) goto <D.7942>; else goto <D.7936>;
        <D.7942>:
        D.7940 = p->prev_foot;
        D.7943 = D.7940 + leadsize;
        newp->prev_foot = D.7943;
        D.7944 = newsize | 2;
        newp->head = D.7944;
        goto <D.7937>;
        <D.7936>:
        D.7945 = newp->head;
        D.7946 = D.7945 & 1;
        D.7947 = D.7946 | newsize;
        D.7948 = D.7947 | 2;
        newp->head = D.7948;
        D.7949 = newp + newsize;
        D.7949 = newp + newsize;
        D.7950 = D.7949->head;
        D.7951 = D.7950 | 1;
        D.7949->head = D.7951;
        D.7934 = p->head;
        D.7938 = D.7934 & 1;
        D.7952 = D.7938 | leadsize;
        D.7953 = D.7952 | 2;
        p->head = D.7953;
        D.7954 = p + leadsize;
        D.7954 = p + leadsize;
        D.7955 = D.7954->head;
        D.7956 = D.7955 | 1;
        D.7954->head = D.7956;
        leader = p + 16;
        <D.7937>:
        p = newp;
      }
      <D.7917>:
      D.7934 = p->head;
      D.7938 = D.7934 & 1;
      if (D.7938 != 0) goto <D.7957>; else goto <D.7959>;
      <D.7959>:
      D.7940 = p->prev_foot;
      D.7941 = D.7940 & 1;
      if (D.7941 == 0) goto <D.7957>; else goto <D.7958>;
      <D.7957>:
      {
        size_t size;

        D.7934 = p->head;
        size = D.7934 & 18446744073709551612;
        D.7960 = nb + 32;
        if (D.7960 < size) goto <D.7961>; else goto <D.7962>;
        <D.7961>:
        {
          size_t remainder_size;
          struct malloc_chunk * remainder;

          remainder_size = size - nb;
          remainder = p + nb;
          D.7934 = p->head;
          D.7938 = D.7934 & 1;
          D.7963 = D.7938 | nb;
          D.7964 = D.7963 | 2;
          p->head = D.7964;
          D.7965 = p + nb;
          D.7965 = p + nb;
          D.7966 = D.7965->head;
          D.7967 = D.7966 | 1;
          D.7965->head = D.7967;
          D.7968 = remainder->head;
          D.7969 = D.7968 & 1;
          D.7970 = D.7969 | remainder_size;
          D.7971 = D.7970 | 2;
          remainder->head = D.7971;
          D.7972 = remainder + remainder_size;
          D.7972 = remainder + remainder_size;
          D.7973 = D.7972->head;
          D.7974 = D.7973 | 1;
          D.7972->head = D.7974;
          trailer = remainder + 16;
        }
        <D.7962>:
      }
      <D.7958>:
      D.7908 = m->mflags;
      D.7909 = D.7908 & 2;
      if (D.7909 != 0) goto <D.7975>; else goto <D.7976>;
      <D.7975>:
      D.7910 = &m->mutex;
      pthread_mutex_unlock (D.7910);
      <D.7976>:
      if (leader != 0B) goto <D.7977>; else goto <D.7978>;
      <D.7977>:
      dlfree (leader);
      <D.7978>:
      if (trailer != 0B) goto <D.7979>; else goto <D.7980>;
      <D.7979>:
      dlfree (trailer);
      <D.7980>:
      D.7880 = p + 16;
      return D.7880;
    }
    <D.7901>:
  }
  <D.7893>:
  D.7880 = 0B;
  return D.7880;
}