From 7f82c29b534b2639efb8bb820663966082dc15f3 Mon Sep 17 00:00:00 2001
From: Phil Dibowitz <phil@ipom.com>
Date: Fri, 31 Mar 2023 18:27:19 -0700
Subject: [PATCH] Add memleak debug history to repo

I'm dropping the "website" for iptstate and just sticking with GH,
and this is the only information specific to the site.
---
 memleak.md |    81 +
 memuse.out | 44976 +++++++++++++++++++++++++++++++++++++++++++++++++++
 2 files changed, 45057 insertions(+)
 create mode 100644 memleak.md
 create mode 100644 memuse.out

diff --git a/memleak.md b/memleak.md
new file mode 100644
index 0000000..9f21819
--- /dev/null
+++ b/memleak.md
@@ -0,0 +1,81 @@
+# IP Tables State - The leak
+
+Back on April 3, 2002, Casey Webster submitted a [Debian Bug
+Report](http://bugs.debian.org/cgi-bin/bugreport.cgi?bug=141044&repeatmerged=yes)
+about a memory leak he found in IPTState. There was certainly a leak SOMEWHERE,
+because when he ran it, it increasingly ate up memory. But looking over my code
+I used no dynamic data structures.
+
+I started researching and for a small amount of time thought it was a bug in
+libc... but it turned out that wasn't true. I then found increasing evidence
+the bug was in ncurses... but nothing hard. I could never prove it. This was a
+function of my own shortcomings.
+
+On October 26, 2002, my Debian Maintainer, Brian Nelson emailed me to tell me
+that Debian was doing a purge. At the end of the week all software with
+outstanding bugs would be kicked out -- and IPTState was on the list. "Oh
+Crap!" I thought. This is perhaps the busiest month I'd ever had. I didn't have
+time to figure this out, I'd already put several hours into it and come up with
+nothing.
+
+Being open source software I called for help. I asked everyone at UUASC and
+USCLUG to do what they could. I even asked for help from the author of Valgrind
+who agreed to help. And many people started looking into it! A huge thanks goes
+out to all of you.
+
+On October 28, 2002, at 12:47am, Steve Augart emailed me with his findings:
+
+```
+Date: Mon, 28 Oct 2002 00:47:29 -0800
+From: Steven Augart <steve@ugart.com>
+To: Brian Nelson <bnelson@bloodclot.net>
+Cc: Phil Dibowitz <phil@ipom.com>
+Subject: Re: iptstate in debian
+
+Well, I've been over it (my God, has it really been two and half hours
+that I spent?) and it's a bug in ncurses.
+
+If someone wants to look at it, ftp to ftp.augart.com and grab the two
+tar files in the directory iptstate. That contains the debugging versions
+I built, specifically:
+
+I made a new version, called "iptstate-castrated.cc".  It takes a new flag,
+-N, which means to not use Curses (kind of like -s, but not just running
+once).  If you run it with -r 0 (meaning to never pause) and -N, you'll find
+that the image never ever bloats.
+
+Since the ncurses calls all look legitimate, it must be a bug in that interface.
+I watched the # of allocated blocks go up during a long run of it.  So, every
+so often ncurses must lose a memory block.
+
+I've attached a shred-malloc trace.  You'll see that it initially is at
+239/240 allocated blocks, and goes up to 240/241 around the 230th iteration.
+(I generated the trace by redirecting stderr to memuse.out).
+
+You can generate a similar trace easily by running iptstate-castrated with -r 0
+and redirecting stderr to a file.
+
+The shred_malloc package is also there, in libSAugart-advanced.tar.gz.
+
+It's already all compiled under SuSE Linux 8.0 (glibc 2.2.5, g++ 2.95.3).
+
+Just because it's a bug in ncurses doesn't mean that the debian folks
+are going to be willing to give iptstate a break.  I would recommend
+building ncurses with -ggdb3 and running one of the memory debuggers
+you tried, one that lists what blocks are allocated and from where.  Get a
+dump after 10 iterations or so.
+
+Then run iptstate again with -r 0 and get a dump after about 2000 iterations.
+Compare the two.
+
+Anyway, that's what I found.
+Please forward this note to the other maintainers.
+```
+
+You can find the output he mentions at [memuse.out](memuse.out).
+
+As he said in the letter you can find his modified source, as well as his memory debugging software in the iptstate directory of [ftp.augart.com](ftp://ftp.augart.com/iptstate/).
+
+In conclusion, this seems to be a bug in ncurses. My software does not leak when it doesn't use ncuses, but leaks very slowly when using ncurses. Brian hopefully will be notifying the ncurses maintainers as well as closing this bug - and iptstate should be able to stay in Debian (and hopefully move into testing).
+
+With that I'd like to say special thanks to Steve Augart, Julian Seward, Todd Lyons, and **everyone** at UUASC and USCLUG who pitched in to help out. There were many of you, and I will try and add more names to this list, but for now I'm trying to post it before I fall asleep. But know that even if you tried, and didn't find anything and thus didn't email me, I still appreciate your effort.
diff --git a/memuse.out b/memuse.out
new file mode 100644
index 0000000..62e556a
--- /dev/null
+++ b/memuse.out
@@ -0,0 +1,44976 @@
+shred_malloc stats:
+hash table sz: 109 blocks
+current: 2 members (2 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 2812 bytes due to overhead.
+(That's 2,812 bytes.)
+Overhead wastage high-water mark: 2812 bytes
+(That's 2,812 bytes.)
+Payload area totals 591104 bytes.
+(That's 591,104 bytes.)
+Payload area high-water mark: 591104 bytes
+(That's 591,104 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+       2 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+       0 calls to shred_free()
+       0 calls to realloc()
+ -------
+       2 calls
+shred_malloc stats:
+hash table sz: 557 blocks
+current: 190 members (190 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 31988 bytes due to overhead.
+(That's 31,988 bytes.)
+Overhead wastage high-water mark: 32086 bytes
+(That's 32,086 bytes.)
+Payload area totals 669202 bytes.
+(That's 669,202 bytes.)
+Payload area high-water mark: 669204 bytes
+(That's 669,204 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+     191 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+       1 calls to shred_free()
+       1 calls to realloc()
+ -------
+     193 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 235 members (235 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 42782 bytes due to overhead.
+(That's 42,782 bytes.)
+Overhead wastage high-water mark: 43076 bytes
+(That's 43,076 bytes.)
+Payload area totals 676987 bytes.
+(That's 676,987 bytes.)
+Payload area high-water mark: 677803 bytes
+(That's 677,803 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+     594 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+     360 calls to shred_free()
+       1 calls to realloc()
+ -------
+     955 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 235 members (235 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 42782 bytes due to overhead.
+(That's 42,782 bytes.)
+Overhead wastage high-water mark: 43076 bytes
+(That's 43,076 bytes.)
+Payload area totals 682805 bytes.
+(That's 682,805 bytes.)
+Payload area high-water mark: 682847 bytes
+(That's 682,847 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+     595 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+     360 calls to shred_free()
+       2 calls to realloc()
+ -------
+     957 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 236 members (236 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 42880 bytes due to overhead.
+(That's 42,880 bytes.)
+Overhead wastage high-water mark: 43174 bytes
+(That's 43,174 bytes.)
+Payload area totals 682829 bytes.
+(That's 682,829 bytes.)
+Payload area high-water mark: 683645 bytes
+(That's 683,645 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+     952 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+     717 calls to shred_free()
+       2 calls to realloc()
+ -------
+    1671 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 239 members (239 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43174 bytes due to overhead.
+(That's 43,174 bytes.)
+Overhead wastage high-water mark: 43272 bytes
+(That's 43,272 bytes.)
+Payload area totals 685809 bytes.
+(That's 685,809 bytes.)
+Payload area high-water mark: 685833 bytes
+(That's 685,833 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+     956 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+     717 calls to shred_free()
+       2 calls to realloc()
+ -------
+    1675 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685833 bytes.
+(That's 685,833 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+    1313 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+    1074 calls to shred_free()
+       2 calls to realloc()
+ -------
+    2389 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 239 members (239 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43174 bytes due to overhead.
+(That's 43,174 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685809 bytes.
+(That's 685,809 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+    1313 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+    1074 calls to shred_free()
+       2 calls to realloc()
+ -------
+    2389 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685833 bytes.
+(That's 685,833 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+    1670 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+    1431 calls to shred_free()
+       2 calls to realloc()
+ -------
+    3103 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 239 members (239 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43174 bytes due to overhead.
+(That's 43,174 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685809 bytes.
+(That's 685,809 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+    1670 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+    1431 calls to shred_free()
+       2 calls to realloc()
+ -------
+    3103 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685833 bytes.
+(That's 685,833 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+    2027 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+    1788 calls to shred_free()
+       2 calls to realloc()
+ -------
+    3817 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 239 members (239 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43174 bytes due to overhead.
+(That's 43,174 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685809 bytes.
+(That's 685,809 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+    2027 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+    1788 calls to shred_free()
+       2 calls to realloc()
+ -------
+    3817 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685833 bytes.
+(That's 685,833 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+    2384 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+    2145 calls to shred_free()
+       2 calls to realloc()
+ -------
+    4531 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 239 members (239 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43174 bytes due to overhead.
+(That's 43,174 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685809 bytes.
+(That's 685,809 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+    2384 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+    2145 calls to shred_free()
+       2 calls to realloc()
+ -------
+    4531 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685833 bytes.
+(That's 685,833 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+    2741 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+    2502 calls to shred_free()
+       2 calls to realloc()
+ -------
+    5245 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 239 members (239 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43174 bytes due to overhead.
+(That's 43,174 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685809 bytes.
+(That's 685,809 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+    2741 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+    2502 calls to shred_free()
+       2 calls to realloc()
+ -------
+    5245 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685833 bytes.
+(That's 685,833 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+    3098 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+    2859 calls to shred_free()
+       2 calls to realloc()
+ -------
+    5959 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 239 members (239 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43174 bytes due to overhead.
+(That's 43,174 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685809 bytes.
+(That's 685,809 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+    3098 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+    2859 calls to shred_free()
+       2 calls to realloc()
+ -------
+    5959 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685833 bytes.
+(That's 685,833 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+    3455 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+    3216 calls to shred_free()
+       2 calls to realloc()
+ -------
+    6673 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 239 members (239 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43174 bytes due to overhead.
+(That's 43,174 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685809 bytes.
+(That's 685,809 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+    3455 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+    3216 calls to shred_free()
+       2 calls to realloc()
+ -------
+    6673 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685833 bytes.
+(That's 685,833 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+    3812 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+    3573 calls to shred_free()
+       2 calls to realloc()
+ -------
+    7387 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 239 members (239 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43174 bytes due to overhead.
+(That's 43,174 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685809 bytes.
+(That's 685,809 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+    3812 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+    3573 calls to shred_free()
+       2 calls to realloc()
+ -------
+    7387 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685833 bytes.
+(That's 685,833 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+    4169 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+    3930 calls to shred_free()
+       2 calls to realloc()
+ -------
+    8101 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 239 members (239 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43174 bytes due to overhead.
+(That's 43,174 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685809 bytes.
+(That's 685,809 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+    4169 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+    3930 calls to shred_free()
+       2 calls to realloc()
+ -------
+    8101 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685833 bytes.
+(That's 685,833 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+    4526 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+    4287 calls to shred_free()
+       2 calls to realloc()
+ -------
+    8815 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 239 members (239 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43174 bytes due to overhead.
+(That's 43,174 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685809 bytes.
+(That's 685,809 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+    4526 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+    4287 calls to shred_free()
+       2 calls to realloc()
+ -------
+    8815 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685833 bytes.
+(That's 685,833 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+    4883 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+    4644 calls to shred_free()
+       2 calls to realloc()
+ -------
+    9529 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 239 members (239 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43174 bytes due to overhead.
+(That's 43,174 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685809 bytes.
+(That's 685,809 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+    4883 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+    4644 calls to shred_free()
+       2 calls to realloc()
+ -------
+    9529 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685833 bytes.
+(That's 685,833 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+    5240 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+    5001 calls to shred_free()
+       2 calls to realloc()
+ -------
+   10243 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 239 members (239 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43174 bytes due to overhead.
+(That's 43,174 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685809 bytes.
+(That's 685,809 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+    5240 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+    5001 calls to shred_free()
+       2 calls to realloc()
+ -------
+   10243 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685833 bytes.
+(That's 685,833 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+    5597 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+    5358 calls to shred_free()
+       2 calls to realloc()
+ -------
+   10957 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 239 members (239 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43174 bytes due to overhead.
+(That's 43,174 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685809 bytes.
+(That's 685,809 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+    5597 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+    5358 calls to shred_free()
+       2 calls to realloc()
+ -------
+   10957 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685833 bytes.
+(That's 685,833 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+    5954 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+    5715 calls to shred_free()
+       2 calls to realloc()
+ -------
+   11671 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 239 members (239 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43174 bytes due to overhead.
+(That's 43,174 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685809 bytes.
+(That's 685,809 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+    5954 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+    5715 calls to shred_free()
+       2 calls to realloc()
+ -------
+   11671 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685833 bytes.
+(That's 685,833 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+    6311 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+    6072 calls to shred_free()
+       2 calls to realloc()
+ -------
+   12385 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 239 members (239 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43174 bytes due to overhead.
+(That's 43,174 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685809 bytes.
+(That's 685,809 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+    6311 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+    6072 calls to shred_free()
+       2 calls to realloc()
+ -------
+   12385 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685833 bytes.
+(That's 685,833 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+    6668 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+    6429 calls to shred_free()
+       2 calls to realloc()
+ -------
+   13099 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 239 members (239 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43174 bytes due to overhead.
+(That's 43,174 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685809 bytes.
+(That's 685,809 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+    6668 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+    6429 calls to shred_free()
+       2 calls to realloc()
+ -------
+   13099 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685833 bytes.
+(That's 685,833 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+    7025 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+    6786 calls to shred_free()
+       2 calls to realloc()
+ -------
+   13813 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 239 members (239 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43174 bytes due to overhead.
+(That's 43,174 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685809 bytes.
+(That's 685,809 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+    7025 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+    6786 calls to shred_free()
+       2 calls to realloc()
+ -------
+   13813 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685833 bytes.
+(That's 685,833 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+    7382 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+    7143 calls to shred_free()
+       2 calls to realloc()
+ -------
+   14527 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 239 members (239 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43174 bytes due to overhead.
+(That's 43,174 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685809 bytes.
+(That's 685,809 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+    7382 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+    7143 calls to shred_free()
+       2 calls to realloc()
+ -------
+   14527 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685833 bytes.
+(That's 685,833 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+    7739 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+    7500 calls to shred_free()
+       2 calls to realloc()
+ -------
+   15241 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 239 members (239 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43174 bytes due to overhead.
+(That's 43,174 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685809 bytes.
+(That's 685,809 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+    7739 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+    7500 calls to shred_free()
+       2 calls to realloc()
+ -------
+   15241 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685833 bytes.
+(That's 685,833 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+    8096 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+    7857 calls to shred_free()
+       2 calls to realloc()
+ -------
+   15955 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 239 members (239 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43174 bytes due to overhead.
+(That's 43,174 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685809 bytes.
+(That's 685,809 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+    8096 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+    7857 calls to shred_free()
+       2 calls to realloc()
+ -------
+   15955 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685833 bytes.
+(That's 685,833 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+    8453 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+    8214 calls to shred_free()
+       2 calls to realloc()
+ -------
+   16669 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 239 members (239 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43174 bytes due to overhead.
+(That's 43,174 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685809 bytes.
+(That's 685,809 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+    8453 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+    8214 calls to shred_free()
+       2 calls to realloc()
+ -------
+   16669 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685833 bytes.
+(That's 685,833 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+    8810 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+    8571 calls to shred_free()
+       2 calls to realloc()
+ -------
+   17383 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 239 members (239 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43174 bytes due to overhead.
+(That's 43,174 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685809 bytes.
+(That's 685,809 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+    8810 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+    8571 calls to shred_free()
+       2 calls to realloc()
+ -------
+   17383 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685833 bytes.
+(That's 685,833 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+    9167 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+    8928 calls to shred_free()
+       2 calls to realloc()
+ -------
+   18097 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 239 members (239 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43174 bytes due to overhead.
+(That's 43,174 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685809 bytes.
+(That's 685,809 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+    9167 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+    8928 calls to shred_free()
+       2 calls to realloc()
+ -------
+   18097 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685833 bytes.
+(That's 685,833 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+    9524 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+    9285 calls to shred_free()
+       2 calls to realloc()
+ -------
+   18811 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 239 members (239 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43174 bytes due to overhead.
+(That's 43,174 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685809 bytes.
+(That's 685,809 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+    9524 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+    9285 calls to shred_free()
+       2 calls to realloc()
+ -------
+   18811 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685833 bytes.
+(That's 685,833 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+    9881 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+    9642 calls to shred_free()
+       2 calls to realloc()
+ -------
+   19525 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 239 members (239 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43174 bytes due to overhead.
+(That's 43,174 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685809 bytes.
+(That's 685,809 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+    9881 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+    9642 calls to shred_free()
+       2 calls to realloc()
+ -------
+   19525 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685833 bytes.
+(That's 685,833 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   10238 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+    9999 calls to shred_free()
+       2 calls to realloc()
+ -------
+   20239 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 239 members (239 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43174 bytes due to overhead.
+(That's 43,174 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685809 bytes.
+(That's 685,809 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   10238 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+    9999 calls to shred_free()
+       2 calls to realloc()
+ -------
+   20239 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685833 bytes.
+(That's 685,833 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   10595 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   10356 calls to shred_free()
+       2 calls to realloc()
+ -------
+   20953 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 239 members (239 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43174 bytes due to overhead.
+(That's 43,174 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685809 bytes.
+(That's 685,809 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   10595 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   10356 calls to shred_free()
+       2 calls to realloc()
+ -------
+   20953 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685833 bytes.
+(That's 685,833 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   10952 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   10713 calls to shred_free()
+       2 calls to realloc()
+ -------
+   21667 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 239 members (239 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43174 bytes due to overhead.
+(That's 43,174 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685809 bytes.
+(That's 685,809 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   10952 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   10713 calls to shred_free()
+       2 calls to realloc()
+ -------
+   21667 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685833 bytes.
+(That's 685,833 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   11309 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   11070 calls to shred_free()
+       2 calls to realloc()
+ -------
+   22381 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 239 members (239 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43174 bytes due to overhead.
+(That's 43,174 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685809 bytes.
+(That's 685,809 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   11309 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   11070 calls to shred_free()
+       2 calls to realloc()
+ -------
+   22381 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685833 bytes.
+(That's 685,833 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   11666 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   11427 calls to shred_free()
+       2 calls to realloc()
+ -------
+   23095 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 239 members (239 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43174 bytes due to overhead.
+(That's 43,174 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685809 bytes.
+(That's 685,809 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   11666 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   11427 calls to shred_free()
+       2 calls to realloc()
+ -------
+   23095 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685833 bytes.
+(That's 685,833 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   12023 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   11784 calls to shred_free()
+       2 calls to realloc()
+ -------
+   23809 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 239 members (239 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43174 bytes due to overhead.
+(That's 43,174 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685809 bytes.
+(That's 685,809 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   12023 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   11784 calls to shred_free()
+       2 calls to realloc()
+ -------
+   23809 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685833 bytes.
+(That's 685,833 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   12380 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   12141 calls to shred_free()
+       2 calls to realloc()
+ -------
+   24523 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 239 members (239 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43174 bytes due to overhead.
+(That's 43,174 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685809 bytes.
+(That's 685,809 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   12380 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   12141 calls to shred_free()
+       2 calls to realloc()
+ -------
+   24523 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685833 bytes.
+(That's 685,833 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   12737 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   12498 calls to shred_free()
+       2 calls to realloc()
+ -------
+   25237 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 239 members (239 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43174 bytes due to overhead.
+(That's 43,174 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685809 bytes.
+(That's 685,809 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   12737 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   12498 calls to shred_free()
+       2 calls to realloc()
+ -------
+   25237 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685833 bytes.
+(That's 685,833 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   13094 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   12855 calls to shred_free()
+       2 calls to realloc()
+ -------
+   25951 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 239 members (239 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43174 bytes due to overhead.
+(That's 43,174 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685809 bytes.
+(That's 685,809 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   13094 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   12855 calls to shred_free()
+       2 calls to realloc()
+ -------
+   25951 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685833 bytes.
+(That's 685,833 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   13451 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   13212 calls to shred_free()
+       2 calls to realloc()
+ -------
+   26665 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 239 members (239 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43174 bytes due to overhead.
+(That's 43,174 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685809 bytes.
+(That's 685,809 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   13451 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   13212 calls to shred_free()
+       2 calls to realloc()
+ -------
+   26665 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685833 bytes.
+(That's 685,833 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   13808 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   13569 calls to shred_free()
+       2 calls to realloc()
+ -------
+   27379 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 239 members (239 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43174 bytes due to overhead.
+(That's 43,174 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685809 bytes.
+(That's 685,809 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   13808 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   13569 calls to shred_free()
+       2 calls to realloc()
+ -------
+   27379 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685833 bytes.
+(That's 685,833 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   14165 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   13926 calls to shred_free()
+       2 calls to realloc()
+ -------
+   28093 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 239 members (239 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43174 bytes due to overhead.
+(That's 43,174 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685809 bytes.
+(That's 685,809 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   14165 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   13926 calls to shred_free()
+       2 calls to realloc()
+ -------
+   28093 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685833 bytes.
+(That's 685,833 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   14522 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   14283 calls to shred_free()
+       2 calls to realloc()
+ -------
+   28807 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 239 members (239 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43174 bytes due to overhead.
+(That's 43,174 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685809 bytes.
+(That's 685,809 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   14522 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   14283 calls to shred_free()
+       2 calls to realloc()
+ -------
+   28807 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685833 bytes.
+(That's 685,833 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   14879 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   14640 calls to shred_free()
+       2 calls to realloc()
+ -------
+   29521 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 239 members (239 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43174 bytes due to overhead.
+(That's 43,174 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685809 bytes.
+(That's 685,809 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   14879 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   14640 calls to shred_free()
+       2 calls to realloc()
+ -------
+   29521 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685833 bytes.
+(That's 685,833 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   15236 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   14997 calls to shred_free()
+       2 calls to realloc()
+ -------
+   30235 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 239 members (239 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43174 bytes due to overhead.
+(That's 43,174 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685809 bytes.
+(That's 685,809 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   15236 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   14997 calls to shred_free()
+       2 calls to realloc()
+ -------
+   30235 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685833 bytes.
+(That's 685,833 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   15593 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   15354 calls to shred_free()
+       2 calls to realloc()
+ -------
+   30949 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 239 members (239 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43174 bytes due to overhead.
+(That's 43,174 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685809 bytes.
+(That's 685,809 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   15593 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   15354 calls to shred_free()
+       2 calls to realloc()
+ -------
+   30949 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685833 bytes.
+(That's 685,833 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   15950 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   15711 calls to shred_free()
+       2 calls to realloc()
+ -------
+   31663 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 239 members (239 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43174 bytes due to overhead.
+(That's 43,174 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685809 bytes.
+(That's 685,809 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   15950 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   15711 calls to shred_free()
+       2 calls to realloc()
+ -------
+   31663 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685833 bytes.
+(That's 685,833 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   16307 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   16068 calls to shred_free()
+       2 calls to realloc()
+ -------
+   32377 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 239 members (239 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43174 bytes due to overhead.
+(That's 43,174 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685809 bytes.
+(That's 685,809 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   16307 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   16068 calls to shred_free()
+       2 calls to realloc()
+ -------
+   32377 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685833 bytes.
+(That's 685,833 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   16664 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   16425 calls to shred_free()
+       2 calls to realloc()
+ -------
+   33091 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 239 members (239 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43174 bytes due to overhead.
+(That's 43,174 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685809 bytes.
+(That's 685,809 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   16664 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   16425 calls to shred_free()
+       2 calls to realloc()
+ -------
+   33091 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685833 bytes.
+(That's 685,833 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   17021 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   16782 calls to shred_free()
+       2 calls to realloc()
+ -------
+   33805 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 239 members (239 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43174 bytes due to overhead.
+(That's 43,174 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685809 bytes.
+(That's 685,809 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   17021 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   16782 calls to shred_free()
+       2 calls to realloc()
+ -------
+   33805 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685833 bytes.
+(That's 685,833 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   17378 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   17139 calls to shred_free()
+       2 calls to realloc()
+ -------
+   34519 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 239 members (239 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43174 bytes due to overhead.
+(That's 43,174 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685809 bytes.
+(That's 685,809 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   17378 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   17139 calls to shred_free()
+       2 calls to realloc()
+ -------
+   34519 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685833 bytes.
+(That's 685,833 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   17735 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   17496 calls to shred_free()
+       2 calls to realloc()
+ -------
+   35233 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 239 members (239 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43174 bytes due to overhead.
+(That's 43,174 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685809 bytes.
+(That's 685,809 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   17735 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   17496 calls to shred_free()
+       2 calls to realloc()
+ -------
+   35233 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685833 bytes.
+(That's 685,833 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   18092 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   17853 calls to shred_free()
+       2 calls to realloc()
+ -------
+   35947 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 239 members (239 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43174 bytes due to overhead.
+(That's 43,174 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685809 bytes.
+(That's 685,809 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   18092 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   17853 calls to shred_free()
+       2 calls to realloc()
+ -------
+   35947 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685833 bytes.
+(That's 685,833 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   18449 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   18210 calls to shred_free()
+       2 calls to realloc()
+ -------
+   36661 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 239 members (239 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43174 bytes due to overhead.
+(That's 43,174 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685809 bytes.
+(That's 685,809 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   18449 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   18210 calls to shred_free()
+       2 calls to realloc()
+ -------
+   36661 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685833 bytes.
+(That's 685,833 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   18806 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   18567 calls to shred_free()
+       2 calls to realloc()
+ -------
+   37375 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 239 members (239 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43174 bytes due to overhead.
+(That's 43,174 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685809 bytes.
+(That's 685,809 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   18806 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   18567 calls to shred_free()
+       2 calls to realloc()
+ -------
+   37375 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685833 bytes.
+(That's 685,833 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   19163 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   18924 calls to shred_free()
+       2 calls to realloc()
+ -------
+   38089 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 239 members (239 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43174 bytes due to overhead.
+(That's 43,174 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685809 bytes.
+(That's 685,809 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   19163 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   18924 calls to shred_free()
+       2 calls to realloc()
+ -------
+   38089 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685833 bytes.
+(That's 685,833 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   19520 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   19281 calls to shred_free()
+       2 calls to realloc()
+ -------
+   38803 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 239 members (239 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43174 bytes due to overhead.
+(That's 43,174 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685809 bytes.
+(That's 685,809 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   19520 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   19281 calls to shred_free()
+       2 calls to realloc()
+ -------
+   38803 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685833 bytes.
+(That's 685,833 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   19877 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   19638 calls to shred_free()
+       2 calls to realloc()
+ -------
+   39517 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 239 members (239 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43174 bytes due to overhead.
+(That's 43,174 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685809 bytes.
+(That's 685,809 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   19877 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   19638 calls to shred_free()
+       2 calls to realloc()
+ -------
+   39517 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685833 bytes.
+(That's 685,833 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   20234 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   19995 calls to shred_free()
+       2 calls to realloc()
+ -------
+   40231 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 239 members (239 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43174 bytes due to overhead.
+(That's 43,174 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685809 bytes.
+(That's 685,809 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   20234 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   19995 calls to shred_free()
+       2 calls to realloc()
+ -------
+   40231 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685833 bytes.
+(That's 685,833 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   20591 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   20352 calls to shred_free()
+       2 calls to realloc()
+ -------
+   40945 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 239 members (239 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43174 bytes due to overhead.
+(That's 43,174 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685809 bytes.
+(That's 685,809 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   20591 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   20352 calls to shred_free()
+       2 calls to realloc()
+ -------
+   40945 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685833 bytes.
+(That's 685,833 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   20948 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   20709 calls to shred_free()
+       2 calls to realloc()
+ -------
+   41659 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 239 members (239 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43174 bytes due to overhead.
+(That's 43,174 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685809 bytes.
+(That's 685,809 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   20948 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   20709 calls to shred_free()
+       2 calls to realloc()
+ -------
+   41659 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685833 bytes.
+(That's 685,833 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   21305 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   21066 calls to shred_free()
+       2 calls to realloc()
+ -------
+   42373 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 239 members (239 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43174 bytes due to overhead.
+(That's 43,174 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685809 bytes.
+(That's 685,809 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   21305 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   21066 calls to shred_free()
+       2 calls to realloc()
+ -------
+   42373 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685833 bytes.
+(That's 685,833 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   21662 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   21423 calls to shred_free()
+       2 calls to realloc()
+ -------
+   43087 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 239 members (239 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43174 bytes due to overhead.
+(That's 43,174 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685809 bytes.
+(That's 685,809 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   21662 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   21423 calls to shred_free()
+       2 calls to realloc()
+ -------
+   43087 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685833 bytes.
+(That's 685,833 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   22019 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   21780 calls to shred_free()
+       2 calls to realloc()
+ -------
+   43801 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 239 members (239 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43174 bytes due to overhead.
+(That's 43,174 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685809 bytes.
+(That's 685,809 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   22019 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   21780 calls to shred_free()
+       2 calls to realloc()
+ -------
+   43801 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685833 bytes.
+(That's 685,833 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   22376 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   22137 calls to shred_free()
+       2 calls to realloc()
+ -------
+   44515 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 239 members (239 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43174 bytes due to overhead.
+(That's 43,174 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685809 bytes.
+(That's 685,809 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   22376 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   22137 calls to shred_free()
+       2 calls to realloc()
+ -------
+   44515 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685833 bytes.
+(That's 685,833 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   22733 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   22494 calls to shred_free()
+       2 calls to realloc()
+ -------
+   45229 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 239 members (239 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43174 bytes due to overhead.
+(That's 43,174 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685809 bytes.
+(That's 685,809 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   22733 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   22494 calls to shred_free()
+       2 calls to realloc()
+ -------
+   45229 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685833 bytes.
+(That's 685,833 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   23090 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   22851 calls to shred_free()
+       2 calls to realloc()
+ -------
+   45943 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 239 members (239 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43174 bytes due to overhead.
+(That's 43,174 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685809 bytes.
+(That's 685,809 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   23090 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   22851 calls to shred_free()
+       2 calls to realloc()
+ -------
+   45943 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685833 bytes.
+(That's 685,833 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   23447 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   23208 calls to shred_free()
+       2 calls to realloc()
+ -------
+   46657 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 239 members (239 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43174 bytes due to overhead.
+(That's 43,174 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685809 bytes.
+(That's 685,809 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   23447 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   23208 calls to shred_free()
+       2 calls to realloc()
+ -------
+   46657 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685833 bytes.
+(That's 685,833 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   23804 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   23565 calls to shred_free()
+       2 calls to realloc()
+ -------
+   47371 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 239 members (239 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43174 bytes due to overhead.
+(That's 43,174 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685809 bytes.
+(That's 685,809 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   23804 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   23565 calls to shred_free()
+       2 calls to realloc()
+ -------
+   47371 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685833 bytes.
+(That's 685,833 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   24161 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   23922 calls to shred_free()
+       2 calls to realloc()
+ -------
+   48085 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 239 members (239 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43174 bytes due to overhead.
+(That's 43,174 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685809 bytes.
+(That's 685,809 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   24161 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   23922 calls to shred_free()
+       2 calls to realloc()
+ -------
+   48085 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685833 bytes.
+(That's 685,833 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   24518 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   24279 calls to shred_free()
+       2 calls to realloc()
+ -------
+   48799 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 239 members (239 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43174 bytes due to overhead.
+(That's 43,174 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685809 bytes.
+(That's 685,809 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   24518 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   24279 calls to shred_free()
+       2 calls to realloc()
+ -------
+   48799 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685833 bytes.
+(That's 685,833 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   24875 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   24636 calls to shred_free()
+       2 calls to realloc()
+ -------
+   49513 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 239 members (239 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43174 bytes due to overhead.
+(That's 43,174 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685809 bytes.
+(That's 685,809 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   24875 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   24636 calls to shred_free()
+       2 calls to realloc()
+ -------
+   49513 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685833 bytes.
+(That's 685,833 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   25232 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   24993 calls to shred_free()
+       2 calls to realloc()
+ -------
+   50227 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 239 members (239 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43174 bytes due to overhead.
+(That's 43,174 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685809 bytes.
+(That's 685,809 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   25232 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   24993 calls to shred_free()
+       2 calls to realloc()
+ -------
+   50227 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685833 bytes.
+(That's 685,833 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   25589 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   25350 calls to shred_free()
+       2 calls to realloc()
+ -------
+   50941 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 239 members (239 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43174 bytes due to overhead.
+(That's 43,174 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685809 bytes.
+(That's 685,809 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   25589 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   25350 calls to shred_free()
+       2 calls to realloc()
+ -------
+   50941 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685833 bytes.
+(That's 685,833 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   25946 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   25707 calls to shred_free()
+       2 calls to realloc()
+ -------
+   51655 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 239 members (239 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43174 bytes due to overhead.
+(That's 43,174 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685809 bytes.
+(That's 685,809 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   25946 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   25707 calls to shred_free()
+       2 calls to realloc()
+ -------
+   51655 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685833 bytes.
+(That's 685,833 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   26303 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   26064 calls to shred_free()
+       2 calls to realloc()
+ -------
+   52369 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 239 members (239 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43174 bytes due to overhead.
+(That's 43,174 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685809 bytes.
+(That's 685,809 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   26303 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   26064 calls to shred_free()
+       2 calls to realloc()
+ -------
+   52369 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685833 bytes.
+(That's 685,833 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   26660 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   26421 calls to shred_free()
+       2 calls to realloc()
+ -------
+   53083 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 239 members (239 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43174 bytes due to overhead.
+(That's 43,174 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685809 bytes.
+(That's 685,809 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   26660 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   26421 calls to shred_free()
+       2 calls to realloc()
+ -------
+   53083 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685833 bytes.
+(That's 685,833 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   27017 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   26778 calls to shred_free()
+       2 calls to realloc()
+ -------
+   53797 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 239 members (239 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43174 bytes due to overhead.
+(That's 43,174 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685809 bytes.
+(That's 685,809 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   27017 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   26778 calls to shred_free()
+       2 calls to realloc()
+ -------
+   53797 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685833 bytes.
+(That's 685,833 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   27374 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   27135 calls to shred_free()
+       2 calls to realloc()
+ -------
+   54511 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 239 members (239 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43174 bytes due to overhead.
+(That's 43,174 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685809 bytes.
+(That's 685,809 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   27374 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   27135 calls to shred_free()
+       2 calls to realloc()
+ -------
+   54511 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685833 bytes.
+(That's 685,833 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   27731 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   27492 calls to shred_free()
+       2 calls to realloc()
+ -------
+   55225 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 239 members (239 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43174 bytes due to overhead.
+(That's 43,174 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685809 bytes.
+(That's 685,809 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   27731 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   27492 calls to shred_free()
+       2 calls to realloc()
+ -------
+   55225 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685833 bytes.
+(That's 685,833 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   28088 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   27849 calls to shred_free()
+       2 calls to realloc()
+ -------
+   55939 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 239 members (239 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43174 bytes due to overhead.
+(That's 43,174 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685809 bytes.
+(That's 685,809 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   28088 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   27849 calls to shred_free()
+       2 calls to realloc()
+ -------
+   55939 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685833 bytes.
+(That's 685,833 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   28445 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   28206 calls to shred_free()
+       2 calls to realloc()
+ -------
+   56653 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 239 members (239 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43174 bytes due to overhead.
+(That's 43,174 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685809 bytes.
+(That's 685,809 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   28445 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   28206 calls to shred_free()
+       2 calls to realloc()
+ -------
+   56653 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685833 bytes.
+(That's 685,833 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   28802 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   28563 calls to shred_free()
+       2 calls to realloc()
+ -------
+   57367 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 239 members (239 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43174 bytes due to overhead.
+(That's 43,174 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685809 bytes.
+(That's 685,809 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   28802 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   28563 calls to shred_free()
+       2 calls to realloc()
+ -------
+   57367 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685833 bytes.
+(That's 685,833 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   29159 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   28920 calls to shred_free()
+       2 calls to realloc()
+ -------
+   58081 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 239 members (239 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43174 bytes due to overhead.
+(That's 43,174 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685809 bytes.
+(That's 685,809 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   29159 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   28920 calls to shred_free()
+       2 calls to realloc()
+ -------
+   58081 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685833 bytes.
+(That's 685,833 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   29516 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   29277 calls to shred_free()
+       2 calls to realloc()
+ -------
+   58795 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 239 members (239 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43174 bytes due to overhead.
+(That's 43,174 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685809 bytes.
+(That's 685,809 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   29516 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   29277 calls to shred_free()
+       2 calls to realloc()
+ -------
+   58795 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685833 bytes.
+(That's 685,833 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   29873 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   29634 calls to shred_free()
+       2 calls to realloc()
+ -------
+   59509 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 239 members (239 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43174 bytes due to overhead.
+(That's 43,174 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685809 bytes.
+(That's 685,809 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   29873 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   29634 calls to shred_free()
+       2 calls to realloc()
+ -------
+   59509 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685833 bytes.
+(That's 685,833 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   30230 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   29991 calls to shred_free()
+       2 calls to realloc()
+ -------
+   60223 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 239 members (239 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43174 bytes due to overhead.
+(That's 43,174 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685809 bytes.
+(That's 685,809 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   30230 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   29991 calls to shred_free()
+       2 calls to realloc()
+ -------
+   60223 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685833 bytes.
+(That's 685,833 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   30587 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   30348 calls to shred_free()
+       2 calls to realloc()
+ -------
+   60937 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 239 members (239 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43174 bytes due to overhead.
+(That's 43,174 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685809 bytes.
+(That's 685,809 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   30587 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   30348 calls to shred_free()
+       2 calls to realloc()
+ -------
+   60937 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685833 bytes.
+(That's 685,833 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   30944 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   30705 calls to shred_free()
+       2 calls to realloc()
+ -------
+   61651 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 239 members (239 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43174 bytes due to overhead.
+(That's 43,174 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685809 bytes.
+(That's 685,809 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   30944 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   30705 calls to shred_free()
+       2 calls to realloc()
+ -------
+   61651 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685833 bytes.
+(That's 685,833 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   31301 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   31062 calls to shred_free()
+       2 calls to realloc()
+ -------
+   62365 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 239 members (239 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43174 bytes due to overhead.
+(That's 43,174 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685809 bytes.
+(That's 685,809 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   31301 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   31062 calls to shred_free()
+       2 calls to realloc()
+ -------
+   62365 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685833 bytes.
+(That's 685,833 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   31658 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   31419 calls to shred_free()
+       2 calls to realloc()
+ -------
+   63079 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 239 members (239 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43174 bytes due to overhead.
+(That's 43,174 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685809 bytes.
+(That's 685,809 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   31658 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   31419 calls to shred_free()
+       2 calls to realloc()
+ -------
+   63079 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685833 bytes.
+(That's 685,833 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   32015 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   31776 calls to shred_free()
+       2 calls to realloc()
+ -------
+   63793 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 239 members (239 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43174 bytes due to overhead.
+(That's 43,174 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685809 bytes.
+(That's 685,809 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   32015 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   31776 calls to shred_free()
+       2 calls to realloc()
+ -------
+   63793 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685833 bytes.
+(That's 685,833 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   32372 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   32133 calls to shred_free()
+       2 calls to realloc()
+ -------
+   64507 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 239 members (239 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43174 bytes due to overhead.
+(That's 43,174 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685809 bytes.
+(That's 685,809 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   32372 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   32133 calls to shred_free()
+       2 calls to realloc()
+ -------
+   64507 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685833 bytes.
+(That's 685,833 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   32729 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   32490 calls to shred_free()
+       2 calls to realloc()
+ -------
+   65221 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 239 members (239 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43174 bytes due to overhead.
+(That's 43,174 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685809 bytes.
+(That's 685,809 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   32729 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   32490 calls to shred_free()
+       2 calls to realloc()
+ -------
+   65221 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685833 bytes.
+(That's 685,833 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   33086 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   32847 calls to shred_free()
+       2 calls to realloc()
+ -------
+   65935 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 239 members (239 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43174 bytes due to overhead.
+(That's 43,174 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685809 bytes.
+(That's 685,809 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   33086 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   32847 calls to shred_free()
+       2 calls to realloc()
+ -------
+   65935 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685833 bytes.
+(That's 685,833 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   33443 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   33204 calls to shred_free()
+       2 calls to realloc()
+ -------
+   66649 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 239 members (239 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43174 bytes due to overhead.
+(That's 43,174 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685809 bytes.
+(That's 685,809 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   33443 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   33204 calls to shred_free()
+       2 calls to realloc()
+ -------
+   66649 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685833 bytes.
+(That's 685,833 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   33800 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   33561 calls to shred_free()
+       2 calls to realloc()
+ -------
+   67363 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 239 members (239 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43174 bytes due to overhead.
+(That's 43,174 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685809 bytes.
+(That's 685,809 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   33800 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   33561 calls to shred_free()
+       2 calls to realloc()
+ -------
+   67363 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685833 bytes.
+(That's 685,833 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   34157 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   33918 calls to shred_free()
+       2 calls to realloc()
+ -------
+   68077 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 239 members (239 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43174 bytes due to overhead.
+(That's 43,174 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685809 bytes.
+(That's 685,809 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   34157 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   33918 calls to shred_free()
+       2 calls to realloc()
+ -------
+   68077 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685833 bytes.
+(That's 685,833 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   34514 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   34275 calls to shred_free()
+       2 calls to realloc()
+ -------
+   68791 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 239 members (239 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43174 bytes due to overhead.
+(That's 43,174 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685809 bytes.
+(That's 685,809 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   34514 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   34275 calls to shred_free()
+       2 calls to realloc()
+ -------
+   68791 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685833 bytes.
+(That's 685,833 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   34871 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   34632 calls to shred_free()
+       2 calls to realloc()
+ -------
+   69505 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 239 members (239 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43174 bytes due to overhead.
+(That's 43,174 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685809 bytes.
+(That's 685,809 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   34871 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   34632 calls to shred_free()
+       2 calls to realloc()
+ -------
+   69505 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685833 bytes.
+(That's 685,833 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   35228 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   34989 calls to shred_free()
+       2 calls to realloc()
+ -------
+   70219 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 239 members (239 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43174 bytes due to overhead.
+(That's 43,174 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685809 bytes.
+(That's 685,809 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   35228 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   34989 calls to shred_free()
+       2 calls to realloc()
+ -------
+   70219 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685833 bytes.
+(That's 685,833 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   35585 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   35346 calls to shred_free()
+       2 calls to realloc()
+ -------
+   70933 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 239 members (239 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43174 bytes due to overhead.
+(That's 43,174 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685809 bytes.
+(That's 685,809 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   35585 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   35346 calls to shred_free()
+       2 calls to realloc()
+ -------
+   70933 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685833 bytes.
+(That's 685,833 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   35942 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   35703 calls to shred_free()
+       2 calls to realloc()
+ -------
+   71647 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 239 members (239 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43174 bytes due to overhead.
+(That's 43,174 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685809 bytes.
+(That's 685,809 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   35942 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   35703 calls to shred_free()
+       2 calls to realloc()
+ -------
+   71647 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685833 bytes.
+(That's 685,833 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   36299 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   36060 calls to shred_free()
+       2 calls to realloc()
+ -------
+   72361 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 239 members (239 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43174 bytes due to overhead.
+(That's 43,174 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685809 bytes.
+(That's 685,809 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   36299 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   36060 calls to shred_free()
+       2 calls to realloc()
+ -------
+   72361 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685833 bytes.
+(That's 685,833 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   36656 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   36417 calls to shred_free()
+       2 calls to realloc()
+ -------
+   73075 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 239 members (239 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43174 bytes due to overhead.
+(That's 43,174 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685809 bytes.
+(That's 685,809 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   36656 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   36417 calls to shred_free()
+       2 calls to realloc()
+ -------
+   73075 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685833 bytes.
+(That's 685,833 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   37013 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   36774 calls to shred_free()
+       2 calls to realloc()
+ -------
+   73789 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 239 members (239 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43174 bytes due to overhead.
+(That's 43,174 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685809 bytes.
+(That's 685,809 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   37013 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   36774 calls to shred_free()
+       2 calls to realloc()
+ -------
+   73789 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685833 bytes.
+(That's 685,833 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   37370 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   37131 calls to shred_free()
+       2 calls to realloc()
+ -------
+   74503 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 239 members (239 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43174 bytes due to overhead.
+(That's 43,174 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685809 bytes.
+(That's 685,809 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   37370 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   37131 calls to shred_free()
+       2 calls to realloc()
+ -------
+   74503 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685833 bytes.
+(That's 685,833 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   37727 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   37488 calls to shred_free()
+       2 calls to realloc()
+ -------
+   75217 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 239 members (239 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43174 bytes due to overhead.
+(That's 43,174 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685809 bytes.
+(That's 685,809 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   37727 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   37488 calls to shred_free()
+       2 calls to realloc()
+ -------
+   75217 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685833 bytes.
+(That's 685,833 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   38084 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   37845 calls to shred_free()
+       2 calls to realloc()
+ -------
+   75931 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 239 members (239 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43174 bytes due to overhead.
+(That's 43,174 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685809 bytes.
+(That's 685,809 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   38084 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   37845 calls to shred_free()
+       2 calls to realloc()
+ -------
+   75931 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685833 bytes.
+(That's 685,833 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   38441 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   38202 calls to shred_free()
+       2 calls to realloc()
+ -------
+   76645 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 239 members (239 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43174 bytes due to overhead.
+(That's 43,174 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685809 bytes.
+(That's 685,809 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   38441 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   38202 calls to shred_free()
+       2 calls to realloc()
+ -------
+   76645 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685833 bytes.
+(That's 685,833 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   38798 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   38559 calls to shred_free()
+       2 calls to realloc()
+ -------
+   77359 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 239 members (239 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43174 bytes due to overhead.
+(That's 43,174 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685809 bytes.
+(That's 685,809 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   38798 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   38559 calls to shred_free()
+       2 calls to realloc()
+ -------
+   77359 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685833 bytes.
+(That's 685,833 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   39155 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   38916 calls to shred_free()
+       2 calls to realloc()
+ -------
+   78073 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 239 members (239 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43174 bytes due to overhead.
+(That's 43,174 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685809 bytes.
+(That's 685,809 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   39155 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   38916 calls to shred_free()
+       2 calls to realloc()
+ -------
+   78073 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685833 bytes.
+(That's 685,833 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   39512 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   39273 calls to shred_free()
+       2 calls to realloc()
+ -------
+   78787 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 239 members (239 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43174 bytes due to overhead.
+(That's 43,174 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685809 bytes.
+(That's 685,809 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   39512 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   39273 calls to shred_free()
+       2 calls to realloc()
+ -------
+   78787 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685833 bytes.
+(That's 685,833 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   39869 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   39630 calls to shred_free()
+       2 calls to realloc()
+ -------
+   79501 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 239 members (239 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43174 bytes due to overhead.
+(That's 43,174 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685809 bytes.
+(That's 685,809 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   39869 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   39630 calls to shred_free()
+       2 calls to realloc()
+ -------
+   79501 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685833 bytes.
+(That's 685,833 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   40226 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   39987 calls to shred_free()
+       2 calls to realloc()
+ -------
+   80215 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 239 members (239 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43174 bytes due to overhead.
+(That's 43,174 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685809 bytes.
+(That's 685,809 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   40226 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   39987 calls to shred_free()
+       2 calls to realloc()
+ -------
+   80215 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685833 bytes.
+(That's 685,833 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   40583 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   40344 calls to shred_free()
+       2 calls to realloc()
+ -------
+   80929 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 239 members (239 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43174 bytes due to overhead.
+(That's 43,174 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685809 bytes.
+(That's 685,809 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   40583 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   40344 calls to shred_free()
+       2 calls to realloc()
+ -------
+   80929 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685833 bytes.
+(That's 685,833 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   40940 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   40701 calls to shred_free()
+       2 calls to realloc()
+ -------
+   81643 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 239 members (239 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43174 bytes due to overhead.
+(That's 43,174 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685809 bytes.
+(That's 685,809 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   40940 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   40701 calls to shred_free()
+       2 calls to realloc()
+ -------
+   81643 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685833 bytes.
+(That's 685,833 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   41297 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   41058 calls to shred_free()
+       2 calls to realloc()
+ -------
+   82357 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 239 members (239 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43174 bytes due to overhead.
+(That's 43,174 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685809 bytes.
+(That's 685,809 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   41297 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   41058 calls to shred_free()
+       2 calls to realloc()
+ -------
+   82357 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685833 bytes.
+(That's 685,833 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   41654 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   41415 calls to shred_free()
+       2 calls to realloc()
+ -------
+   83071 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 239 members (239 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43174 bytes due to overhead.
+(That's 43,174 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685809 bytes.
+(That's 685,809 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   41654 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   41415 calls to shred_free()
+       2 calls to realloc()
+ -------
+   83071 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685833 bytes.
+(That's 685,833 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   42011 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   41772 calls to shred_free()
+       2 calls to realloc()
+ -------
+   83785 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 239 members (239 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43174 bytes due to overhead.
+(That's 43,174 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685809 bytes.
+(That's 685,809 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   42011 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   41772 calls to shred_free()
+       2 calls to realloc()
+ -------
+   83785 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685833 bytes.
+(That's 685,833 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   42368 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   42129 calls to shred_free()
+       2 calls to realloc()
+ -------
+   84499 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 239 members (239 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43174 bytes due to overhead.
+(That's 43,174 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685809 bytes.
+(That's 685,809 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   42368 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   42129 calls to shred_free()
+       2 calls to realloc()
+ -------
+   84499 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685833 bytes.
+(That's 685,833 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   42725 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   42486 calls to shred_free()
+       2 calls to realloc()
+ -------
+   85213 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 239 members (239 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43174 bytes due to overhead.
+(That's 43,174 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685809 bytes.
+(That's 685,809 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   42725 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   42486 calls to shred_free()
+       2 calls to realloc()
+ -------
+   85213 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685833 bytes.
+(That's 685,833 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   43082 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   42843 calls to shred_free()
+       2 calls to realloc()
+ -------
+   85927 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 239 members (239 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43174 bytes due to overhead.
+(That's 43,174 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685809 bytes.
+(That's 685,809 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   43082 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   42843 calls to shred_free()
+       2 calls to realloc()
+ -------
+   85927 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685833 bytes.
+(That's 685,833 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   43439 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   43200 calls to shred_free()
+       2 calls to realloc()
+ -------
+   86641 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 239 members (239 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43174 bytes due to overhead.
+(That's 43,174 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685809 bytes.
+(That's 685,809 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   43439 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   43200 calls to shred_free()
+       2 calls to realloc()
+ -------
+   86641 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685833 bytes.
+(That's 685,833 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   43796 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   43557 calls to shred_free()
+       2 calls to realloc()
+ -------
+   87355 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 239 members (239 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43174 bytes due to overhead.
+(That's 43,174 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685809 bytes.
+(That's 685,809 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   43796 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   43557 calls to shred_free()
+       2 calls to realloc()
+ -------
+   87355 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685833 bytes.
+(That's 685,833 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   44153 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   43914 calls to shred_free()
+       2 calls to realloc()
+ -------
+   88069 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 239 members (239 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43174 bytes due to overhead.
+(That's 43,174 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685809 bytes.
+(That's 685,809 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   44153 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   43914 calls to shred_free()
+       2 calls to realloc()
+ -------
+   88069 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685833 bytes.
+(That's 685,833 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   44510 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   44271 calls to shred_free()
+       2 calls to realloc()
+ -------
+   88783 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 239 members (239 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43174 bytes due to overhead.
+(That's 43,174 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685809 bytes.
+(That's 685,809 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   44510 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   44271 calls to shred_free()
+       2 calls to realloc()
+ -------
+   88783 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685833 bytes.
+(That's 685,833 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   44867 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   44628 calls to shred_free()
+       2 calls to realloc()
+ -------
+   89497 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 239 members (239 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43174 bytes due to overhead.
+(That's 43,174 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685809 bytes.
+(That's 685,809 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   44867 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   44628 calls to shred_free()
+       2 calls to realloc()
+ -------
+   89497 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685833 bytes.
+(That's 685,833 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   45224 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   44985 calls to shred_free()
+       2 calls to realloc()
+ -------
+   90211 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 239 members (239 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43174 bytes due to overhead.
+(That's 43,174 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685809 bytes.
+(That's 685,809 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   45224 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   44985 calls to shred_free()
+       2 calls to realloc()
+ -------
+   90211 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685833 bytes.
+(That's 685,833 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   45581 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   45342 calls to shred_free()
+       2 calls to realloc()
+ -------
+   90925 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 239 members (239 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43174 bytes due to overhead.
+(That's 43,174 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685809 bytes.
+(That's 685,809 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   45581 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   45342 calls to shred_free()
+       2 calls to realloc()
+ -------
+   90925 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685833 bytes.
+(That's 685,833 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   45938 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   45699 calls to shred_free()
+       2 calls to realloc()
+ -------
+   91639 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 239 members (239 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43174 bytes due to overhead.
+(That's 43,174 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685809 bytes.
+(That's 685,809 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   45938 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   45699 calls to shred_free()
+       2 calls to realloc()
+ -------
+   91639 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685833 bytes.
+(That's 685,833 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   46295 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   46056 calls to shred_free()
+       2 calls to realloc()
+ -------
+   92353 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 239 members (239 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43174 bytes due to overhead.
+(That's 43,174 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685809 bytes.
+(That's 685,809 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   46295 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   46056 calls to shred_free()
+       2 calls to realloc()
+ -------
+   92353 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685833 bytes.
+(That's 685,833 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   46652 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   46413 calls to shred_free()
+       2 calls to realloc()
+ -------
+   93067 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 239 members (239 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43174 bytes due to overhead.
+(That's 43,174 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685809 bytes.
+(That's 685,809 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   46652 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   46413 calls to shred_free()
+       2 calls to realloc()
+ -------
+   93067 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685833 bytes.
+(That's 685,833 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   47009 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   46770 calls to shred_free()
+       2 calls to realloc()
+ -------
+   93781 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 239 members (239 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43174 bytes due to overhead.
+(That's 43,174 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685809 bytes.
+(That's 685,809 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   47009 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   46770 calls to shred_free()
+       2 calls to realloc()
+ -------
+   93781 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685833 bytes.
+(That's 685,833 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   47366 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   47127 calls to shred_free()
+       2 calls to realloc()
+ -------
+   94495 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 239 members (239 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43174 bytes due to overhead.
+(That's 43,174 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685809 bytes.
+(That's 685,809 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   47366 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   47127 calls to shred_free()
+       2 calls to realloc()
+ -------
+   94495 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685833 bytes.
+(That's 685,833 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   47723 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   47484 calls to shred_free()
+       2 calls to realloc()
+ -------
+   95209 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 239 members (239 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43174 bytes due to overhead.
+(That's 43,174 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685809 bytes.
+(That's 685,809 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   47723 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   47484 calls to shred_free()
+       2 calls to realloc()
+ -------
+   95209 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685833 bytes.
+(That's 685,833 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   48080 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   47841 calls to shred_free()
+       2 calls to realloc()
+ -------
+   95923 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 239 members (239 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43174 bytes due to overhead.
+(That's 43,174 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685809 bytes.
+(That's 685,809 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   48080 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   47841 calls to shred_free()
+       2 calls to realloc()
+ -------
+   95923 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685833 bytes.
+(That's 685,833 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   48437 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   48198 calls to shred_free()
+       2 calls to realloc()
+ -------
+   96637 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 239 members (239 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43174 bytes due to overhead.
+(That's 43,174 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685809 bytes.
+(That's 685,809 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   48437 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   48198 calls to shred_free()
+       2 calls to realloc()
+ -------
+   96637 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685833 bytes.
+(That's 685,833 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   48794 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   48555 calls to shred_free()
+       2 calls to realloc()
+ -------
+   97351 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 239 members (239 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43174 bytes due to overhead.
+(That's 43,174 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685809 bytes.
+(That's 685,809 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   48794 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   48555 calls to shred_free()
+       2 calls to realloc()
+ -------
+   97351 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685833 bytes.
+(That's 685,833 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   49151 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   48912 calls to shred_free()
+       2 calls to realloc()
+ -------
+   98065 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 239 members (239 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43174 bytes due to overhead.
+(That's 43,174 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685809 bytes.
+(That's 685,809 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   49151 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   48912 calls to shred_free()
+       2 calls to realloc()
+ -------
+   98065 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685833 bytes.
+(That's 685,833 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   49508 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   49269 calls to shred_free()
+       2 calls to realloc()
+ -------
+   98779 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 239 members (239 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43174 bytes due to overhead.
+(That's 43,174 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685809 bytes.
+(That's 685,809 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   49508 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   49269 calls to shred_free()
+       2 calls to realloc()
+ -------
+   98779 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685833 bytes.
+(That's 685,833 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   49865 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   49626 calls to shred_free()
+       2 calls to realloc()
+ -------
+   99493 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 239 members (239 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43174 bytes due to overhead.
+(That's 43,174 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685809 bytes.
+(That's 685,809 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   49865 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   49626 calls to shred_free()
+       2 calls to realloc()
+ -------
+   99493 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685833 bytes.
+(That's 685,833 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   50222 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   49983 calls to shred_free()
+       2 calls to realloc()
+ -------
+  100207 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 239 members (239 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43174 bytes due to overhead.
+(That's 43,174 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685809 bytes.
+(That's 685,809 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   50222 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   49983 calls to shred_free()
+       2 calls to realloc()
+ -------
+  100207 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685833 bytes.
+(That's 685,833 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   50579 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   50340 calls to shred_free()
+       2 calls to realloc()
+ -------
+  100921 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 239 members (239 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43174 bytes due to overhead.
+(That's 43,174 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685809 bytes.
+(That's 685,809 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   50579 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   50340 calls to shred_free()
+       2 calls to realloc()
+ -------
+  100921 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685833 bytes.
+(That's 685,833 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   50936 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   50697 calls to shred_free()
+       2 calls to realloc()
+ -------
+  101635 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 239 members (239 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43174 bytes due to overhead.
+(That's 43,174 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685809 bytes.
+(That's 685,809 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   50936 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   50697 calls to shred_free()
+       2 calls to realloc()
+ -------
+  101635 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685833 bytes.
+(That's 685,833 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   51293 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   51054 calls to shred_free()
+       2 calls to realloc()
+ -------
+  102349 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 239 members (239 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43174 bytes due to overhead.
+(That's 43,174 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685809 bytes.
+(That's 685,809 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   51293 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   51054 calls to shred_free()
+       2 calls to realloc()
+ -------
+  102349 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685833 bytes.
+(That's 685,833 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   51650 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   51411 calls to shred_free()
+       2 calls to realloc()
+ -------
+  103063 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 239 members (239 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43174 bytes due to overhead.
+(That's 43,174 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685809 bytes.
+(That's 685,809 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   51650 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   51411 calls to shred_free()
+       2 calls to realloc()
+ -------
+  103063 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685833 bytes.
+(That's 685,833 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   52007 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   51768 calls to shred_free()
+       2 calls to realloc()
+ -------
+  103777 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 239 members (239 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43174 bytes due to overhead.
+(That's 43,174 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685809 bytes.
+(That's 685,809 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   52007 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   51768 calls to shred_free()
+       2 calls to realloc()
+ -------
+  103777 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685833 bytes.
+(That's 685,833 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   52364 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   52125 calls to shred_free()
+       2 calls to realloc()
+ -------
+  104491 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 239 members (239 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43174 bytes due to overhead.
+(That's 43,174 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685809 bytes.
+(That's 685,809 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   52364 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   52125 calls to shred_free()
+       2 calls to realloc()
+ -------
+  104491 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685833 bytes.
+(That's 685,833 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   52721 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   52482 calls to shred_free()
+       2 calls to realloc()
+ -------
+  105205 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 239 members (239 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43174 bytes due to overhead.
+(That's 43,174 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685809 bytes.
+(That's 685,809 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   52721 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   52482 calls to shred_free()
+       2 calls to realloc()
+ -------
+  105205 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685833 bytes.
+(That's 685,833 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   53078 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   52839 calls to shred_free()
+       2 calls to realloc()
+ -------
+  105919 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 239 members (239 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43174 bytes due to overhead.
+(That's 43,174 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685809 bytes.
+(That's 685,809 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   53078 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   52839 calls to shred_free()
+       2 calls to realloc()
+ -------
+  105919 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685833 bytes.
+(That's 685,833 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   53435 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   53196 calls to shred_free()
+       2 calls to realloc()
+ -------
+  106633 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 239 members (239 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43174 bytes due to overhead.
+(That's 43,174 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685809 bytes.
+(That's 685,809 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   53435 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   53196 calls to shred_free()
+       2 calls to realloc()
+ -------
+  106633 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685833 bytes.
+(That's 685,833 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   53792 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   53553 calls to shred_free()
+       2 calls to realloc()
+ -------
+  107347 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 239 members (239 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43174 bytes due to overhead.
+(That's 43,174 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685809 bytes.
+(That's 685,809 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   53792 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   53553 calls to shred_free()
+       2 calls to realloc()
+ -------
+  107347 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685833 bytes.
+(That's 685,833 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   54149 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   53910 calls to shred_free()
+       2 calls to realloc()
+ -------
+  108061 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 239 members (239 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43174 bytes due to overhead.
+(That's 43,174 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685809 bytes.
+(That's 685,809 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   54149 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   53910 calls to shred_free()
+       2 calls to realloc()
+ -------
+  108061 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685833 bytes.
+(That's 685,833 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   54506 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   54267 calls to shred_free()
+       2 calls to realloc()
+ -------
+  108775 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 239 members (239 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43174 bytes due to overhead.
+(That's 43,174 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685809 bytes.
+(That's 685,809 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   54506 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   54267 calls to shred_free()
+       2 calls to realloc()
+ -------
+  108775 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685833 bytes.
+(That's 685,833 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   54863 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   54624 calls to shred_free()
+       2 calls to realloc()
+ -------
+  109489 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 239 members (239 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43174 bytes due to overhead.
+(That's 43,174 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685809 bytes.
+(That's 685,809 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   54863 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   54624 calls to shred_free()
+       2 calls to realloc()
+ -------
+  109489 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685833 bytes.
+(That's 685,833 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   55220 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   54981 calls to shred_free()
+       2 calls to realloc()
+ -------
+  110203 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 239 members (239 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43174 bytes due to overhead.
+(That's 43,174 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685809 bytes.
+(That's 685,809 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   55220 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   54981 calls to shred_free()
+       2 calls to realloc()
+ -------
+  110203 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685833 bytes.
+(That's 685,833 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   55577 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   55338 calls to shred_free()
+       2 calls to realloc()
+ -------
+  110917 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 239 members (239 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43174 bytes due to overhead.
+(That's 43,174 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685809 bytes.
+(That's 685,809 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   55577 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   55338 calls to shred_free()
+       2 calls to realloc()
+ -------
+  110917 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685833 bytes.
+(That's 685,833 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   55934 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   55695 calls to shred_free()
+       2 calls to realloc()
+ -------
+  111631 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 239 members (239 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43174 bytes due to overhead.
+(That's 43,174 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685809 bytes.
+(That's 685,809 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   55934 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   55695 calls to shred_free()
+       2 calls to realloc()
+ -------
+  111631 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685833 bytes.
+(That's 685,833 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   56291 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   56052 calls to shred_free()
+       2 calls to realloc()
+ -------
+  112345 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 239 members (239 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43174 bytes due to overhead.
+(That's 43,174 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685809 bytes.
+(That's 685,809 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   56291 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   56052 calls to shred_free()
+       2 calls to realloc()
+ -------
+  112345 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685833 bytes.
+(That's 685,833 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   56648 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   56409 calls to shred_free()
+       2 calls to realloc()
+ -------
+  113059 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 239 members (239 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43174 bytes due to overhead.
+(That's 43,174 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685809 bytes.
+(That's 685,809 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   56648 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   56409 calls to shred_free()
+       2 calls to realloc()
+ -------
+  113059 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685833 bytes.
+(That's 685,833 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   57005 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   56766 calls to shred_free()
+       2 calls to realloc()
+ -------
+  113773 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 239 members (239 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43174 bytes due to overhead.
+(That's 43,174 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685809 bytes.
+(That's 685,809 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   57005 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   56766 calls to shred_free()
+       2 calls to realloc()
+ -------
+  113773 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685833 bytes.
+(That's 685,833 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   57362 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   57123 calls to shred_free()
+       2 calls to realloc()
+ -------
+  114487 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 239 members (239 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43174 bytes due to overhead.
+(That's 43,174 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685809 bytes.
+(That's 685,809 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   57362 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   57123 calls to shred_free()
+       2 calls to realloc()
+ -------
+  114487 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685833 bytes.
+(That's 685,833 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   57719 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   57480 calls to shred_free()
+       2 calls to realloc()
+ -------
+  115201 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 239 members (239 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43174 bytes due to overhead.
+(That's 43,174 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685809 bytes.
+(That's 685,809 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   57719 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   57480 calls to shred_free()
+       2 calls to realloc()
+ -------
+  115201 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685833 bytes.
+(That's 685,833 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   58076 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   57837 calls to shred_free()
+       2 calls to realloc()
+ -------
+  115915 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 239 members (239 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43174 bytes due to overhead.
+(That's 43,174 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685809 bytes.
+(That's 685,809 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   58076 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   57837 calls to shred_free()
+       2 calls to realloc()
+ -------
+  115915 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685833 bytes.
+(That's 685,833 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   58433 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   58194 calls to shred_free()
+       2 calls to realloc()
+ -------
+  116629 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 239 members (239 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43174 bytes due to overhead.
+(That's 43,174 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685809 bytes.
+(That's 685,809 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   58433 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   58194 calls to shred_free()
+       2 calls to realloc()
+ -------
+  116629 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685833 bytes.
+(That's 685,833 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   58790 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   58551 calls to shred_free()
+       2 calls to realloc()
+ -------
+  117343 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 239 members (239 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43174 bytes due to overhead.
+(That's 43,174 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685809 bytes.
+(That's 685,809 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   58790 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   58551 calls to shred_free()
+       2 calls to realloc()
+ -------
+  117343 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685833 bytes.
+(That's 685,833 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   59147 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   58908 calls to shred_free()
+       2 calls to realloc()
+ -------
+  118057 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 239 members (239 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43174 bytes due to overhead.
+(That's 43,174 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685809 bytes.
+(That's 685,809 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   59147 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   58908 calls to shred_free()
+       2 calls to realloc()
+ -------
+  118057 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685833 bytes.
+(That's 685,833 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   59504 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   59265 calls to shred_free()
+       2 calls to realloc()
+ -------
+  118771 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 239 members (239 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43174 bytes due to overhead.
+(That's 43,174 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685809 bytes.
+(That's 685,809 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   59504 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   59265 calls to shred_free()
+       2 calls to realloc()
+ -------
+  118771 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685833 bytes.
+(That's 685,833 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   59861 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   59622 calls to shred_free()
+       2 calls to realloc()
+ -------
+  119485 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 239 members (239 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43174 bytes due to overhead.
+(That's 43,174 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685809 bytes.
+(That's 685,809 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   59861 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   59622 calls to shred_free()
+       2 calls to realloc()
+ -------
+  119485 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685833 bytes.
+(That's 685,833 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   60218 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   59979 calls to shred_free()
+       2 calls to realloc()
+ -------
+  120199 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 239 members (239 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43174 bytes due to overhead.
+(That's 43,174 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685809 bytes.
+(That's 685,809 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   60218 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   59979 calls to shred_free()
+       2 calls to realloc()
+ -------
+  120199 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685833 bytes.
+(That's 685,833 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   60575 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   60336 calls to shred_free()
+       2 calls to realloc()
+ -------
+  120913 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 239 members (239 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43174 bytes due to overhead.
+(That's 43,174 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685809 bytes.
+(That's 685,809 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   60575 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   60336 calls to shred_free()
+       2 calls to realloc()
+ -------
+  120913 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685833 bytes.
+(That's 685,833 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   60932 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   60693 calls to shred_free()
+       2 calls to realloc()
+ -------
+  121627 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 239 members (239 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43174 bytes due to overhead.
+(That's 43,174 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685809 bytes.
+(That's 685,809 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   60932 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   60693 calls to shred_free()
+       2 calls to realloc()
+ -------
+  121627 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685833 bytes.
+(That's 685,833 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   61289 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   61050 calls to shred_free()
+       2 calls to realloc()
+ -------
+  122341 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 239 members (239 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43174 bytes due to overhead.
+(That's 43,174 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685809 bytes.
+(That's 685,809 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   61289 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   61050 calls to shred_free()
+       2 calls to realloc()
+ -------
+  122341 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685833 bytes.
+(That's 685,833 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   61646 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   61407 calls to shred_free()
+       2 calls to realloc()
+ -------
+  123055 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 239 members (239 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43174 bytes due to overhead.
+(That's 43,174 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685809 bytes.
+(That's 685,809 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   61646 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   61407 calls to shred_free()
+       2 calls to realloc()
+ -------
+  123055 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685833 bytes.
+(That's 685,833 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   62003 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   61764 calls to shred_free()
+       2 calls to realloc()
+ -------
+  123769 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 239 members (239 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43174 bytes due to overhead.
+(That's 43,174 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685809 bytes.
+(That's 685,809 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   62003 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   61764 calls to shred_free()
+       2 calls to realloc()
+ -------
+  123769 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685833 bytes.
+(That's 685,833 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   62360 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   62121 calls to shred_free()
+       2 calls to realloc()
+ -------
+  124483 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 239 members (239 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43174 bytes due to overhead.
+(That's 43,174 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685809 bytes.
+(That's 685,809 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   62360 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   62121 calls to shred_free()
+       2 calls to realloc()
+ -------
+  124483 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685833 bytes.
+(That's 685,833 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   62717 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   62478 calls to shred_free()
+       2 calls to realloc()
+ -------
+  125197 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 239 members (239 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43174 bytes due to overhead.
+(That's 43,174 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685809 bytes.
+(That's 685,809 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   62717 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   62478 calls to shred_free()
+       2 calls to realloc()
+ -------
+  125197 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685833 bytes.
+(That's 685,833 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   63074 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   62835 calls to shred_free()
+       2 calls to realloc()
+ -------
+  125911 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 239 members (239 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43174 bytes due to overhead.
+(That's 43,174 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685809 bytes.
+(That's 685,809 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   63074 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   62835 calls to shred_free()
+       2 calls to realloc()
+ -------
+  125911 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685833 bytes.
+(That's 685,833 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   63431 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   63192 calls to shred_free()
+       2 calls to realloc()
+ -------
+  126625 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 239 members (239 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43174 bytes due to overhead.
+(That's 43,174 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685809 bytes.
+(That's 685,809 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   63431 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   63192 calls to shred_free()
+       2 calls to realloc()
+ -------
+  126625 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685833 bytes.
+(That's 685,833 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   63788 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   63549 calls to shred_free()
+       2 calls to realloc()
+ -------
+  127339 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 239 members (239 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43174 bytes due to overhead.
+(That's 43,174 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685809 bytes.
+(That's 685,809 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   63788 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   63549 calls to shred_free()
+       2 calls to realloc()
+ -------
+  127339 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685833 bytes.
+(That's 685,833 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   64145 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   63906 calls to shred_free()
+       2 calls to realloc()
+ -------
+  128053 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 239 members (239 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43174 bytes due to overhead.
+(That's 43,174 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685809 bytes.
+(That's 685,809 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   64145 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   63906 calls to shred_free()
+       2 calls to realloc()
+ -------
+  128053 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685833 bytes.
+(That's 685,833 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   64502 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   64263 calls to shred_free()
+       2 calls to realloc()
+ -------
+  128767 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 239 members (239 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43174 bytes due to overhead.
+(That's 43,174 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685809 bytes.
+(That's 685,809 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   64502 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   64263 calls to shred_free()
+       2 calls to realloc()
+ -------
+  128767 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685833 bytes.
+(That's 685,833 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   64859 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   64620 calls to shred_free()
+       2 calls to realloc()
+ -------
+  129481 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 239 members (239 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43174 bytes due to overhead.
+(That's 43,174 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685809 bytes.
+(That's 685,809 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   64859 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   64620 calls to shred_free()
+       2 calls to realloc()
+ -------
+  129481 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685833 bytes.
+(That's 685,833 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   65216 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   64977 calls to shred_free()
+       2 calls to realloc()
+ -------
+  130195 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 239 members (239 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43174 bytes due to overhead.
+(That's 43,174 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685809 bytes.
+(That's 685,809 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   65216 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   64977 calls to shred_free()
+       2 calls to realloc()
+ -------
+  130195 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685833 bytes.
+(That's 685,833 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   65573 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   65334 calls to shred_free()
+       2 calls to realloc()
+ -------
+  130909 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 239 members (239 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43174 bytes due to overhead.
+(That's 43,174 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685809 bytes.
+(That's 685,809 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   65573 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   65334 calls to shred_free()
+       2 calls to realloc()
+ -------
+  130909 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685833 bytes.
+(That's 685,833 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   65930 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   65691 calls to shred_free()
+       2 calls to realloc()
+ -------
+  131623 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 239 members (239 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43174 bytes due to overhead.
+(That's 43,174 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685809 bytes.
+(That's 685,809 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   65930 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   65691 calls to shred_free()
+       2 calls to realloc()
+ -------
+  131623 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685833 bytes.
+(That's 685,833 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   66287 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   66048 calls to shred_free()
+       2 calls to realloc()
+ -------
+  132337 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 239 members (239 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43174 bytes due to overhead.
+(That's 43,174 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685809 bytes.
+(That's 685,809 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   66287 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   66048 calls to shred_free()
+       2 calls to realloc()
+ -------
+  132337 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685833 bytes.
+(That's 685,833 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   66644 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   66405 calls to shred_free()
+       2 calls to realloc()
+ -------
+  133051 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 239 members (239 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43174 bytes due to overhead.
+(That's 43,174 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685809 bytes.
+(That's 685,809 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   66644 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   66405 calls to shred_free()
+       2 calls to realloc()
+ -------
+  133051 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685833 bytes.
+(That's 685,833 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   67001 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   66762 calls to shred_free()
+       2 calls to realloc()
+ -------
+  133765 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 239 members (239 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43174 bytes due to overhead.
+(That's 43,174 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685809 bytes.
+(That's 685,809 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   67001 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   66762 calls to shred_free()
+       2 calls to realloc()
+ -------
+  133765 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685833 bytes.
+(That's 685,833 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   67358 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   67119 calls to shred_free()
+       2 calls to realloc()
+ -------
+  134479 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 239 members (239 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43174 bytes due to overhead.
+(That's 43,174 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685809 bytes.
+(That's 685,809 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   67358 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   67119 calls to shred_free()
+       2 calls to realloc()
+ -------
+  134479 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685833 bytes.
+(That's 685,833 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   67715 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   67476 calls to shred_free()
+       2 calls to realloc()
+ -------
+  135193 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 239 members (239 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43174 bytes due to overhead.
+(That's 43,174 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685809 bytes.
+(That's 685,809 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   67715 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   67476 calls to shred_free()
+       2 calls to realloc()
+ -------
+  135193 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685833 bytes.
+(That's 685,833 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   68072 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   67833 calls to shred_free()
+       2 calls to realloc()
+ -------
+  135907 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 239 members (239 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43174 bytes due to overhead.
+(That's 43,174 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685809 bytes.
+(That's 685,809 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   68072 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   67833 calls to shred_free()
+       2 calls to realloc()
+ -------
+  135907 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685833 bytes.
+(That's 685,833 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   68429 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   68190 calls to shred_free()
+       2 calls to realloc()
+ -------
+  136621 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 239 members (239 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43174 bytes due to overhead.
+(That's 43,174 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685809 bytes.
+(That's 685,809 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   68429 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   68190 calls to shred_free()
+       2 calls to realloc()
+ -------
+  136621 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685833 bytes.
+(That's 685,833 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   68786 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   68547 calls to shred_free()
+       2 calls to realloc()
+ -------
+  137335 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 239 members (239 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43174 bytes due to overhead.
+(That's 43,174 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685809 bytes.
+(That's 685,809 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   68786 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   68547 calls to shred_free()
+       2 calls to realloc()
+ -------
+  137335 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685833 bytes.
+(That's 685,833 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   69143 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   68904 calls to shred_free()
+       2 calls to realloc()
+ -------
+  138049 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 239 members (239 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43174 bytes due to overhead.
+(That's 43,174 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685809 bytes.
+(That's 685,809 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   69143 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   68904 calls to shred_free()
+       2 calls to realloc()
+ -------
+  138049 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685833 bytes.
+(That's 685,833 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   69500 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   69261 calls to shred_free()
+       2 calls to realloc()
+ -------
+  138763 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 239 members (239 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43174 bytes due to overhead.
+(That's 43,174 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685809 bytes.
+(That's 685,809 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   69500 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   69261 calls to shred_free()
+       2 calls to realloc()
+ -------
+  138763 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685833 bytes.
+(That's 685,833 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   69857 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   69618 calls to shred_free()
+       2 calls to realloc()
+ -------
+  139477 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 239 members (239 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43174 bytes due to overhead.
+(That's 43,174 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685809 bytes.
+(That's 685,809 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   69857 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   69618 calls to shred_free()
+       2 calls to realloc()
+ -------
+  139477 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685833 bytes.
+(That's 685,833 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   70214 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   69975 calls to shred_free()
+       2 calls to realloc()
+ -------
+  140191 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 239 members (239 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43174 bytes due to overhead.
+(That's 43,174 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685809 bytes.
+(That's 685,809 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   70214 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   69975 calls to shred_free()
+       2 calls to realloc()
+ -------
+  140191 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685833 bytes.
+(That's 685,833 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   70571 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   70332 calls to shred_free()
+       2 calls to realloc()
+ -------
+  140905 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 239 members (239 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43174 bytes due to overhead.
+(That's 43,174 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685809 bytes.
+(That's 685,809 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   70571 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   70332 calls to shred_free()
+       2 calls to realloc()
+ -------
+  140905 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685833 bytes.
+(That's 685,833 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   70928 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   70689 calls to shred_free()
+       2 calls to realloc()
+ -------
+  141619 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 239 members (239 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43174 bytes due to overhead.
+(That's 43,174 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685809 bytes.
+(That's 685,809 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   70928 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   70689 calls to shred_free()
+       2 calls to realloc()
+ -------
+  141619 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685833 bytes.
+(That's 685,833 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   71285 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   71046 calls to shred_free()
+       2 calls to realloc()
+ -------
+  142333 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 239 members (239 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43174 bytes due to overhead.
+(That's 43,174 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685809 bytes.
+(That's 685,809 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   71285 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   71046 calls to shred_free()
+       2 calls to realloc()
+ -------
+  142333 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685833 bytes.
+(That's 685,833 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   71642 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   71403 calls to shred_free()
+       2 calls to realloc()
+ -------
+  143047 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 239 members (239 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43174 bytes due to overhead.
+(That's 43,174 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685809 bytes.
+(That's 685,809 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   71642 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   71403 calls to shred_free()
+       2 calls to realloc()
+ -------
+  143047 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685833 bytes.
+(That's 685,833 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   71999 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   71760 calls to shred_free()
+       2 calls to realloc()
+ -------
+  143761 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 239 members (239 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43174 bytes due to overhead.
+(That's 43,174 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685809 bytes.
+(That's 685,809 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   71999 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   71760 calls to shred_free()
+       2 calls to realloc()
+ -------
+  143761 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685833 bytes.
+(That's 685,833 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   72356 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   72117 calls to shred_free()
+       2 calls to realloc()
+ -------
+  144475 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 239 members (239 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43174 bytes due to overhead.
+(That's 43,174 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685809 bytes.
+(That's 685,809 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   72356 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   72117 calls to shred_free()
+       2 calls to realloc()
+ -------
+  144475 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685833 bytes.
+(That's 685,833 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   72713 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   72474 calls to shred_free()
+       2 calls to realloc()
+ -------
+  145189 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 239 members (239 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43174 bytes due to overhead.
+(That's 43,174 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685809 bytes.
+(That's 685,809 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   72713 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   72474 calls to shred_free()
+       2 calls to realloc()
+ -------
+  145189 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685833 bytes.
+(That's 685,833 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   73070 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   72831 calls to shred_free()
+       2 calls to realloc()
+ -------
+  145903 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 239 members (239 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43174 bytes due to overhead.
+(That's 43,174 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685809 bytes.
+(That's 685,809 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   73070 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   72831 calls to shred_free()
+       2 calls to realloc()
+ -------
+  145903 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685833 bytes.
+(That's 685,833 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   73427 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   73188 calls to shred_free()
+       2 calls to realloc()
+ -------
+  146617 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 239 members (239 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43174 bytes due to overhead.
+(That's 43,174 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685809 bytes.
+(That's 685,809 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   73427 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   73188 calls to shred_free()
+       2 calls to realloc()
+ -------
+  146617 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685833 bytes.
+(That's 685,833 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   73784 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   73545 calls to shred_free()
+       2 calls to realloc()
+ -------
+  147331 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 239 members (239 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43174 bytes due to overhead.
+(That's 43,174 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685809 bytes.
+(That's 685,809 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   73784 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   73545 calls to shred_free()
+       2 calls to realloc()
+ -------
+  147331 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685833 bytes.
+(That's 685,833 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   74141 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   73902 calls to shred_free()
+       2 calls to realloc()
+ -------
+  148045 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 239 members (239 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43174 bytes due to overhead.
+(That's 43,174 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685809 bytes.
+(That's 685,809 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   74141 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   73902 calls to shred_free()
+       2 calls to realloc()
+ -------
+  148045 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685833 bytes.
+(That's 685,833 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   74498 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   74259 calls to shred_free()
+       2 calls to realloc()
+ -------
+  148759 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 239 members (239 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43174 bytes due to overhead.
+(That's 43,174 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685809 bytes.
+(That's 685,809 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   74498 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   74259 calls to shred_free()
+       2 calls to realloc()
+ -------
+  148759 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685833 bytes.
+(That's 685,833 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   74855 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   74616 calls to shred_free()
+       2 calls to realloc()
+ -------
+  149473 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 239 members (239 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43174 bytes due to overhead.
+(That's 43,174 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685809 bytes.
+(That's 685,809 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   74855 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   74616 calls to shred_free()
+       2 calls to realloc()
+ -------
+  149473 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685833 bytes.
+(That's 685,833 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   75212 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   74973 calls to shred_free()
+       2 calls to realloc()
+ -------
+  150187 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 239 members (239 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43174 bytes due to overhead.
+(That's 43,174 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685809 bytes.
+(That's 685,809 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   75212 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   74973 calls to shred_free()
+       2 calls to realloc()
+ -------
+  150187 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685833 bytes.
+(That's 685,833 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   75569 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   75330 calls to shred_free()
+       2 calls to realloc()
+ -------
+  150901 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 239 members (239 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43174 bytes due to overhead.
+(That's 43,174 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685809 bytes.
+(That's 685,809 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   75569 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   75330 calls to shred_free()
+       2 calls to realloc()
+ -------
+  150901 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685833 bytes.
+(That's 685,833 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   75926 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   75687 calls to shred_free()
+       2 calls to realloc()
+ -------
+  151615 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 239 members (239 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43174 bytes due to overhead.
+(That's 43,174 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685809 bytes.
+(That's 685,809 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   75926 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   75687 calls to shred_free()
+       2 calls to realloc()
+ -------
+  151615 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685833 bytes.
+(That's 685,833 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   76283 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   76044 calls to shred_free()
+       2 calls to realloc()
+ -------
+  152329 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 239 members (239 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43174 bytes due to overhead.
+(That's 43,174 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685809 bytes.
+(That's 685,809 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   76283 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   76044 calls to shred_free()
+       2 calls to realloc()
+ -------
+  152329 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685833 bytes.
+(That's 685,833 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   76640 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   76401 calls to shred_free()
+       2 calls to realloc()
+ -------
+  153043 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 239 members (239 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43174 bytes due to overhead.
+(That's 43,174 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685809 bytes.
+(That's 685,809 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   76640 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   76401 calls to shred_free()
+       2 calls to realloc()
+ -------
+  153043 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685833 bytes.
+(That's 685,833 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   76997 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   76758 calls to shred_free()
+       2 calls to realloc()
+ -------
+  153757 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 239 members (239 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43174 bytes due to overhead.
+(That's 43,174 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685809 bytes.
+(That's 685,809 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   76997 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   76758 calls to shred_free()
+       2 calls to realloc()
+ -------
+  153757 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685833 bytes.
+(That's 685,833 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   77354 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   77115 calls to shred_free()
+       2 calls to realloc()
+ -------
+  154471 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 239 members (239 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43174 bytes due to overhead.
+(That's 43,174 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685809 bytes.
+(That's 685,809 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   77354 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   77115 calls to shred_free()
+       2 calls to realloc()
+ -------
+  154471 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685833 bytes.
+(That's 685,833 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   77711 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   77472 calls to shred_free()
+       2 calls to realloc()
+ -------
+  155185 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 239 members (239 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43174 bytes due to overhead.
+(That's 43,174 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685809 bytes.
+(That's 685,809 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   77711 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   77472 calls to shred_free()
+       2 calls to realloc()
+ -------
+  155185 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685833 bytes.
+(That's 685,833 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   78068 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   77829 calls to shred_free()
+       2 calls to realloc()
+ -------
+  155899 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 239 members (239 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43174 bytes due to overhead.
+(That's 43,174 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685809 bytes.
+(That's 685,809 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   78068 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   77829 calls to shred_free()
+       2 calls to realloc()
+ -------
+  155899 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685833 bytes.
+(That's 685,833 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   78425 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   78186 calls to shred_free()
+       2 calls to realloc()
+ -------
+  156613 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 239 members (239 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43174 bytes due to overhead.
+(That's 43,174 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685809 bytes.
+(That's 685,809 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   78425 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   78186 calls to shred_free()
+       2 calls to realloc()
+ -------
+  156613 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685833 bytes.
+(That's 685,833 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   78782 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   78543 calls to shred_free()
+       2 calls to realloc()
+ -------
+  157327 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 239 members (239 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43174 bytes due to overhead.
+(That's 43,174 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685809 bytes.
+(That's 685,809 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   78782 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   78543 calls to shred_free()
+       2 calls to realloc()
+ -------
+  157327 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685833 bytes.
+(That's 685,833 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   79139 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   78900 calls to shred_free()
+       2 calls to realloc()
+ -------
+  158041 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 239 members (239 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43174 bytes due to overhead.
+(That's 43,174 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685809 bytes.
+(That's 685,809 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   79139 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   78900 calls to shred_free()
+       2 calls to realloc()
+ -------
+  158041 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685833 bytes.
+(That's 685,833 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   79496 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   79257 calls to shred_free()
+       2 calls to realloc()
+ -------
+  158755 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 239 members (239 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43174 bytes due to overhead.
+(That's 43,174 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685809 bytes.
+(That's 685,809 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   79496 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   79257 calls to shred_free()
+       2 calls to realloc()
+ -------
+  158755 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685833 bytes.
+(That's 685,833 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   79853 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   79614 calls to shred_free()
+       2 calls to realloc()
+ -------
+  159469 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 239 members (239 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43174 bytes due to overhead.
+(That's 43,174 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685809 bytes.
+(That's 685,809 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   79853 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   79614 calls to shred_free()
+       2 calls to realloc()
+ -------
+  159469 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685833 bytes.
+(That's 685,833 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   80210 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   79971 calls to shred_free()
+       2 calls to realloc()
+ -------
+  160183 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 239 members (239 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43174 bytes due to overhead.
+(That's 43,174 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685809 bytes.
+(That's 685,809 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   80210 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   79971 calls to shred_free()
+       2 calls to realloc()
+ -------
+  160183 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685833 bytes.
+(That's 685,833 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   80567 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   80328 calls to shred_free()
+       2 calls to realloc()
+ -------
+  160897 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 239 members (239 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43174 bytes due to overhead.
+(That's 43,174 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685809 bytes.
+(That's 685,809 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   80567 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   80328 calls to shred_free()
+       2 calls to realloc()
+ -------
+  160897 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685833 bytes.
+(That's 685,833 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   80924 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   80685 calls to shred_free()
+       2 calls to realloc()
+ -------
+  161611 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 239 members (239 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43174 bytes due to overhead.
+(That's 43,174 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685809 bytes.
+(That's 685,809 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   80924 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   80685 calls to shred_free()
+       2 calls to realloc()
+ -------
+  161611 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685833 bytes.
+(That's 685,833 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   81281 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   81042 calls to shred_free()
+       2 calls to realloc()
+ -------
+  162325 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 239 members (239 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43174 bytes due to overhead.
+(That's 43,174 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685809 bytes.
+(That's 685,809 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   81281 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   81042 calls to shred_free()
+       2 calls to realloc()
+ -------
+  162325 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685833 bytes.
+(That's 685,833 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   81638 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   81399 calls to shred_free()
+       2 calls to realloc()
+ -------
+  163039 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 239 members (239 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43174 bytes due to overhead.
+(That's 43,174 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685809 bytes.
+(That's 685,809 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   81638 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   81399 calls to shred_free()
+       2 calls to realloc()
+ -------
+  163039 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685833 bytes.
+(That's 685,833 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   81995 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   81756 calls to shred_free()
+       2 calls to realloc()
+ -------
+  163753 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 239 members (239 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43174 bytes due to overhead.
+(That's 43,174 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685809 bytes.
+(That's 685,809 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   81995 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   81756 calls to shred_free()
+       2 calls to realloc()
+ -------
+  163753 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685833 bytes.
+(That's 685,833 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   82352 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   82113 calls to shred_free()
+       2 calls to realloc()
+ -------
+  164467 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 239 members (239 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43174 bytes due to overhead.
+(That's 43,174 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685809 bytes.
+(That's 685,809 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   82352 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   82113 calls to shred_free()
+       2 calls to realloc()
+ -------
+  164467 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685833 bytes.
+(That's 685,833 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   82709 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   82470 calls to shred_free()
+       2 calls to realloc()
+ -------
+  165181 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 239 members (239 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43174 bytes due to overhead.
+(That's 43,174 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685809 bytes.
+(That's 685,809 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   82709 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   82470 calls to shred_free()
+       2 calls to realloc()
+ -------
+  165181 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685833 bytes.
+(That's 685,833 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   83066 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   82827 calls to shred_free()
+       2 calls to realloc()
+ -------
+  165895 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 239 members (239 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43174 bytes due to overhead.
+(That's 43,174 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685809 bytes.
+(That's 685,809 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   83066 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   82827 calls to shred_free()
+       2 calls to realloc()
+ -------
+  165895 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685833 bytes.
+(That's 685,833 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   83423 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   83184 calls to shred_free()
+       2 calls to realloc()
+ -------
+  166609 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 239 members (239 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43174 bytes due to overhead.
+(That's 43,174 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685809 bytes.
+(That's 685,809 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   83423 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   83184 calls to shred_free()
+       2 calls to realloc()
+ -------
+  166609 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685833 bytes.
+(That's 685,833 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   83780 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   83541 calls to shred_free()
+       2 calls to realloc()
+ -------
+  167323 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 239 members (239 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43174 bytes due to overhead.
+(That's 43,174 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685809 bytes.
+(That's 685,809 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   83780 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   83541 calls to shred_free()
+       2 calls to realloc()
+ -------
+  167323 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685833 bytes.
+(That's 685,833 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   84137 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   83898 calls to shred_free()
+       2 calls to realloc()
+ -------
+  168037 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 239 members (239 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43174 bytes due to overhead.
+(That's 43,174 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685809 bytes.
+(That's 685,809 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   84137 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   83898 calls to shred_free()
+       2 calls to realloc()
+ -------
+  168037 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685833 bytes.
+(That's 685,833 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   84494 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   84255 calls to shred_free()
+       2 calls to realloc()
+ -------
+  168751 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 239 members (239 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43174 bytes due to overhead.
+(That's 43,174 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685809 bytes.
+(That's 685,809 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   84494 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   84255 calls to shred_free()
+       2 calls to realloc()
+ -------
+  168751 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685833 bytes.
+(That's 685,833 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   84851 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   84612 calls to shred_free()
+       2 calls to realloc()
+ -------
+  169465 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 239 members (239 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43174 bytes due to overhead.
+(That's 43,174 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685809 bytes.
+(That's 685,809 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   84851 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   84612 calls to shred_free()
+       2 calls to realloc()
+ -------
+  169465 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685833 bytes.
+(That's 685,833 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   85208 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   84969 calls to shred_free()
+       2 calls to realloc()
+ -------
+  170179 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 239 members (239 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43174 bytes due to overhead.
+(That's 43,174 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685809 bytes.
+(That's 685,809 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   85208 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   84969 calls to shred_free()
+       2 calls to realloc()
+ -------
+  170179 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685833 bytes.
+(That's 685,833 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   85565 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   85326 calls to shred_free()
+       2 calls to realloc()
+ -------
+  170893 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 239 members (239 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43174 bytes due to overhead.
+(That's 43,174 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685809 bytes.
+(That's 685,809 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   85565 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   85326 calls to shred_free()
+       2 calls to realloc()
+ -------
+  170893 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685833 bytes.
+(That's 685,833 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   85922 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   85683 calls to shred_free()
+       2 calls to realloc()
+ -------
+  171607 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 239 members (239 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43174 bytes due to overhead.
+(That's 43,174 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685809 bytes.
+(That's 685,809 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   85922 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   85683 calls to shred_free()
+       2 calls to realloc()
+ -------
+  171607 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685833 bytes.
+(That's 685,833 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   86279 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   86040 calls to shred_free()
+       2 calls to realloc()
+ -------
+  172321 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 239 members (239 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43174 bytes due to overhead.
+(That's 43,174 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685809 bytes.
+(That's 685,809 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   86279 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   86040 calls to shred_free()
+       2 calls to realloc()
+ -------
+  172321 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685833 bytes.
+(That's 685,833 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   86636 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   86397 calls to shred_free()
+       2 calls to realloc()
+ -------
+  173035 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 239 members (239 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43174 bytes due to overhead.
+(That's 43,174 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685809 bytes.
+(That's 685,809 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   86636 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   86397 calls to shred_free()
+       2 calls to realloc()
+ -------
+  173035 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685833 bytes.
+(That's 685,833 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   86993 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   86754 calls to shred_free()
+       2 calls to realloc()
+ -------
+  173749 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 239 members (239 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43174 bytes due to overhead.
+(That's 43,174 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685809 bytes.
+(That's 685,809 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   86993 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   86754 calls to shred_free()
+       2 calls to realloc()
+ -------
+  173749 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685833 bytes.
+(That's 685,833 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   87350 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   87111 calls to shred_free()
+       2 calls to realloc()
+ -------
+  174463 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 239 members (239 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43174 bytes due to overhead.
+(That's 43,174 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685809 bytes.
+(That's 685,809 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   87350 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   87111 calls to shred_free()
+       2 calls to realloc()
+ -------
+  174463 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685833 bytes.
+(That's 685,833 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   87707 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   87468 calls to shred_free()
+       2 calls to realloc()
+ -------
+  175177 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 239 members (239 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43174 bytes due to overhead.
+(That's 43,174 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685809 bytes.
+(That's 685,809 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   87707 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   87468 calls to shred_free()
+       2 calls to realloc()
+ -------
+  175177 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685833 bytes.
+(That's 685,833 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   88064 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   87825 calls to shred_free()
+       2 calls to realloc()
+ -------
+  175891 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 239 members (239 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43174 bytes due to overhead.
+(That's 43,174 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685809 bytes.
+(That's 685,809 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   88064 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   87825 calls to shred_free()
+       2 calls to realloc()
+ -------
+  175891 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685833 bytes.
+(That's 685,833 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   88421 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   88182 calls to shred_free()
+       2 calls to realloc()
+ -------
+  176605 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 239 members (239 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43174 bytes due to overhead.
+(That's 43,174 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685809 bytes.
+(That's 685,809 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   88421 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   88182 calls to shred_free()
+       2 calls to realloc()
+ -------
+  176605 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685833 bytes.
+(That's 685,833 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   88778 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   88539 calls to shred_free()
+       2 calls to realloc()
+ -------
+  177319 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 239 members (239 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43174 bytes due to overhead.
+(That's 43,174 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685809 bytes.
+(That's 685,809 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   88778 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   88539 calls to shred_free()
+       2 calls to realloc()
+ -------
+  177319 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685833 bytes.
+(That's 685,833 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   89135 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   88896 calls to shred_free()
+       2 calls to realloc()
+ -------
+  178033 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 239 members (239 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43174 bytes due to overhead.
+(That's 43,174 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685809 bytes.
+(That's 685,809 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   89135 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   88896 calls to shred_free()
+       2 calls to realloc()
+ -------
+  178033 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685833 bytes.
+(That's 685,833 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   89492 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   89253 calls to shred_free()
+       2 calls to realloc()
+ -------
+  178747 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 239 members (239 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43174 bytes due to overhead.
+(That's 43,174 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685809 bytes.
+(That's 685,809 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   89492 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   89253 calls to shred_free()
+       2 calls to realloc()
+ -------
+  178747 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685833 bytes.
+(That's 685,833 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   89849 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   89610 calls to shred_free()
+       2 calls to realloc()
+ -------
+  179461 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 239 members (239 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43174 bytes due to overhead.
+(That's 43,174 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685809 bytes.
+(That's 685,809 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   89849 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   89610 calls to shred_free()
+       2 calls to realloc()
+ -------
+  179461 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685833 bytes.
+(That's 685,833 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   90206 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   89967 calls to shred_free()
+       2 calls to realloc()
+ -------
+  180175 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 239 members (239 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43174 bytes due to overhead.
+(That's 43,174 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685809 bytes.
+(That's 685,809 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   90206 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   89967 calls to shred_free()
+       2 calls to realloc()
+ -------
+  180175 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685833 bytes.
+(That's 685,833 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   90563 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   90324 calls to shred_free()
+       2 calls to realloc()
+ -------
+  180889 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 239 members (239 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43174 bytes due to overhead.
+(That's 43,174 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685809 bytes.
+(That's 685,809 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   90563 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   90324 calls to shred_free()
+       2 calls to realloc()
+ -------
+  180889 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685833 bytes.
+(That's 685,833 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   90920 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   90681 calls to shred_free()
+       2 calls to realloc()
+ -------
+  181603 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 239 members (239 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43174 bytes due to overhead.
+(That's 43,174 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685809 bytes.
+(That's 685,809 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   90920 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   90681 calls to shred_free()
+       2 calls to realloc()
+ -------
+  181603 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685833 bytes.
+(That's 685,833 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   91277 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   91038 calls to shred_free()
+       2 calls to realloc()
+ -------
+  182317 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 239 members (239 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43174 bytes due to overhead.
+(That's 43,174 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685809 bytes.
+(That's 685,809 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   91277 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   91038 calls to shred_free()
+       2 calls to realloc()
+ -------
+  182317 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685833 bytes.
+(That's 685,833 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   91634 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   91395 calls to shred_free()
+       2 calls to realloc()
+ -------
+  183031 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 239 members (239 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43174 bytes due to overhead.
+(That's 43,174 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685809 bytes.
+(That's 685,809 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   91634 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   91395 calls to shred_free()
+       2 calls to realloc()
+ -------
+  183031 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685833 bytes.
+(That's 685,833 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   91991 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   91752 calls to shred_free()
+       2 calls to realloc()
+ -------
+  183745 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 239 members (239 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43174 bytes due to overhead.
+(That's 43,174 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685809 bytes.
+(That's 685,809 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   91991 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   91752 calls to shred_free()
+       2 calls to realloc()
+ -------
+  183745 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685833 bytes.
+(That's 685,833 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   92348 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   92109 calls to shred_free()
+       2 calls to realloc()
+ -------
+  184459 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 239 members (239 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43174 bytes due to overhead.
+(That's 43,174 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685809 bytes.
+(That's 685,809 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   92348 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   92109 calls to shred_free()
+       2 calls to realloc()
+ -------
+  184459 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685833 bytes.
+(That's 685,833 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   92705 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   92466 calls to shred_free()
+       2 calls to realloc()
+ -------
+  185173 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 239 members (239 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43174 bytes due to overhead.
+(That's 43,174 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685809 bytes.
+(That's 685,809 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   92705 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   92466 calls to shred_free()
+       2 calls to realloc()
+ -------
+  185173 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685833 bytes.
+(That's 685,833 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   93062 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   92823 calls to shred_free()
+       2 calls to realloc()
+ -------
+  185887 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 239 members (239 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43174 bytes due to overhead.
+(That's 43,174 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685809 bytes.
+(That's 685,809 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   93062 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   92823 calls to shred_free()
+       2 calls to realloc()
+ -------
+  185887 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685833 bytes.
+(That's 685,833 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   93419 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   93180 calls to shred_free()
+       2 calls to realloc()
+ -------
+  186601 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 239 members (239 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43174 bytes due to overhead.
+(That's 43,174 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685809 bytes.
+(That's 685,809 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   93419 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   93180 calls to shred_free()
+       2 calls to realloc()
+ -------
+  186601 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685833 bytes.
+(That's 685,833 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   93776 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   93537 calls to shred_free()
+       2 calls to realloc()
+ -------
+  187315 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 239 members (239 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43174 bytes due to overhead.
+(That's 43,174 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685809 bytes.
+(That's 685,809 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   93776 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   93537 calls to shred_free()
+       2 calls to realloc()
+ -------
+  187315 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685833 bytes.
+(That's 685,833 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   94133 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   93894 calls to shred_free()
+       2 calls to realloc()
+ -------
+  188029 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 239 members (239 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43174 bytes due to overhead.
+(That's 43,174 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685809 bytes.
+(That's 685,809 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   94133 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   93894 calls to shred_free()
+       2 calls to realloc()
+ -------
+  188029 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685833 bytes.
+(That's 685,833 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   94490 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   94251 calls to shred_free()
+       2 calls to realloc()
+ -------
+  188743 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 239 members (239 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43174 bytes due to overhead.
+(That's 43,174 bytes.)
+Overhead wastage high-water mark: 43566 bytes
+(That's 43,566 bytes.)
+Payload area totals 685809 bytes.
+(That's 685,809 bytes.)
+Payload area high-water mark: 686649 bytes
+(That's 686,649 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   94490 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   94251 calls to shred_free()
+       2 calls to realloc()
+ -------
+  188743 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688149 bytes
+(That's 688,149 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   94897 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   94657 calls to shred_free()
+       2 calls to realloc()
+ -------
+  189556 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688149 bytes
+(That's 688,149 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   94897 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   94657 calls to shred_free()
+       2 calls to realloc()
+ -------
+  189556 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   95302 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   95062 calls to shred_free()
+       2 calls to realloc()
+ -------
+  190366 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   95302 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   95062 calls to shred_free()
+       2 calls to realloc()
+ -------
+  190366 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   95707 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   95467 calls to shred_free()
+       2 calls to realloc()
+ -------
+  191176 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   95707 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   95467 calls to shred_free()
+       2 calls to realloc()
+ -------
+  191176 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   96112 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   95872 calls to shred_free()
+       2 calls to realloc()
+ -------
+  191986 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   96112 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   95872 calls to shred_free()
+       2 calls to realloc()
+ -------
+  191986 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   96501 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   96261 calls to shred_free()
+       2 calls to realloc()
+ -------
+  192764 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   96501 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   96261 calls to shred_free()
+       2 calls to realloc()
+ -------
+  192764 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   96888 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   96648 calls to shred_free()
+       2 calls to realloc()
+ -------
+  193538 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   96888 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   96648 calls to shred_free()
+       2 calls to realloc()
+ -------
+  193538 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   97275 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   97035 calls to shred_free()
+       2 calls to realloc()
+ -------
+  194312 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   97275 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   97035 calls to shred_free()
+       2 calls to realloc()
+ -------
+  194312 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   97662 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   97422 calls to shred_free()
+       2 calls to realloc()
+ -------
+  195086 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   97662 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   97422 calls to shred_free()
+       2 calls to realloc()
+ -------
+  195086 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   98049 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   97809 calls to shred_free()
+       2 calls to realloc()
+ -------
+  195860 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   98049 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   97809 calls to shred_free()
+       2 calls to realloc()
+ -------
+  195860 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   98436 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   98196 calls to shred_free()
+       2 calls to realloc()
+ -------
+  196634 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   98436 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   98196 calls to shred_free()
+       2 calls to realloc()
+ -------
+  196634 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   98823 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   98583 calls to shred_free()
+       2 calls to realloc()
+ -------
+  197408 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   98823 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   98583 calls to shred_free()
+       2 calls to realloc()
+ -------
+  197408 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   99210 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   98970 calls to shred_free()
+       2 calls to realloc()
+ -------
+  198182 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   99210 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   98970 calls to shred_free()
+       2 calls to realloc()
+ -------
+  198182 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   99597 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   99357 calls to shred_free()
+       2 calls to realloc()
+ -------
+  198956 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   99597 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   99357 calls to shred_free()
+       2 calls to realloc()
+ -------
+  198956 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   99984 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   99744 calls to shred_free()
+       2 calls to realloc()
+ -------
+  199730 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+   99984 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+   99744 calls to shred_free()
+       2 calls to realloc()
+ -------
+  199730 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  100371 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  100131 calls to shred_free()
+       2 calls to realloc()
+ -------
+  200504 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  100371 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  100131 calls to shred_free()
+       2 calls to realloc()
+ -------
+  200504 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  100758 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  100518 calls to shred_free()
+       2 calls to realloc()
+ -------
+  201278 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  100758 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  100518 calls to shred_free()
+       2 calls to realloc()
+ -------
+  201278 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  101145 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  100905 calls to shred_free()
+       2 calls to realloc()
+ -------
+  202052 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  101145 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  100905 calls to shred_free()
+       2 calls to realloc()
+ -------
+  202052 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  101532 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  101292 calls to shred_free()
+       2 calls to realloc()
+ -------
+  202826 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  101532 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  101292 calls to shred_free()
+       2 calls to realloc()
+ -------
+  202826 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  101919 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  101679 calls to shred_free()
+       2 calls to realloc()
+ -------
+  203600 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  101919 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  101679 calls to shred_free()
+       2 calls to realloc()
+ -------
+  203600 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  102306 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  102066 calls to shred_free()
+       2 calls to realloc()
+ -------
+  204374 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  102306 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  102066 calls to shred_free()
+       2 calls to realloc()
+ -------
+  204374 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  102693 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  102453 calls to shred_free()
+       2 calls to realloc()
+ -------
+  205148 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  102693 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  102453 calls to shred_free()
+       2 calls to realloc()
+ -------
+  205148 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  103080 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  102840 calls to shred_free()
+       2 calls to realloc()
+ -------
+  205922 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  103080 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  102840 calls to shred_free()
+       2 calls to realloc()
+ -------
+  205922 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  103467 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  103227 calls to shred_free()
+       2 calls to realloc()
+ -------
+  206696 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  103467 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  103227 calls to shred_free()
+       2 calls to realloc()
+ -------
+  206696 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  103854 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  103614 calls to shred_free()
+       2 calls to realloc()
+ -------
+  207470 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  103854 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  103614 calls to shred_free()
+       2 calls to realloc()
+ -------
+  207470 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  104241 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  104001 calls to shred_free()
+       2 calls to realloc()
+ -------
+  208244 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  104241 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  104001 calls to shred_free()
+       2 calls to realloc()
+ -------
+  208244 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  104628 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  104388 calls to shred_free()
+       2 calls to realloc()
+ -------
+  209018 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  104628 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  104388 calls to shred_free()
+       2 calls to realloc()
+ -------
+  209018 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  105015 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  104775 calls to shred_free()
+       2 calls to realloc()
+ -------
+  209792 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  105015 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  104775 calls to shred_free()
+       2 calls to realloc()
+ -------
+  209792 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  105402 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  105162 calls to shred_free()
+       2 calls to realloc()
+ -------
+  210566 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  105402 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  105162 calls to shred_free()
+       2 calls to realloc()
+ -------
+  210566 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  105789 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  105549 calls to shred_free()
+       2 calls to realloc()
+ -------
+  211340 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  105789 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  105549 calls to shred_free()
+       2 calls to realloc()
+ -------
+  211340 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  106176 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  105936 calls to shred_free()
+       2 calls to realloc()
+ -------
+  212114 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  106176 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  105936 calls to shred_free()
+       2 calls to realloc()
+ -------
+  212114 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  106563 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  106323 calls to shred_free()
+       2 calls to realloc()
+ -------
+  212888 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  106563 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  106323 calls to shred_free()
+       2 calls to realloc()
+ -------
+  212888 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  106950 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  106710 calls to shred_free()
+       2 calls to realloc()
+ -------
+  213662 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  106950 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  106710 calls to shred_free()
+       2 calls to realloc()
+ -------
+  213662 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  107337 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  107097 calls to shred_free()
+       2 calls to realloc()
+ -------
+  214436 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  107337 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  107097 calls to shred_free()
+       2 calls to realloc()
+ -------
+  214436 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  107724 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  107484 calls to shred_free()
+       2 calls to realloc()
+ -------
+  215210 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  107724 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  107484 calls to shred_free()
+       2 calls to realloc()
+ -------
+  215210 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  108111 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  107871 calls to shred_free()
+       2 calls to realloc()
+ -------
+  215984 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  108111 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  107871 calls to shred_free()
+       2 calls to realloc()
+ -------
+  215984 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  108498 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  108258 calls to shred_free()
+       2 calls to realloc()
+ -------
+  216758 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  108498 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  108258 calls to shred_free()
+       2 calls to realloc()
+ -------
+  216758 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  108885 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  108645 calls to shred_free()
+       2 calls to realloc()
+ -------
+  217532 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  108885 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  108645 calls to shred_free()
+       2 calls to realloc()
+ -------
+  217532 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  109272 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  109032 calls to shred_free()
+       2 calls to realloc()
+ -------
+  218306 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  109272 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  109032 calls to shred_free()
+       2 calls to realloc()
+ -------
+  218306 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  109659 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  109419 calls to shred_free()
+       2 calls to realloc()
+ -------
+  219080 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  109659 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  109419 calls to shred_free()
+       2 calls to realloc()
+ -------
+  219080 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  110046 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  109806 calls to shred_free()
+       2 calls to realloc()
+ -------
+  219854 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  110046 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  109806 calls to shred_free()
+       2 calls to realloc()
+ -------
+  219854 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  110433 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  110193 calls to shred_free()
+       2 calls to realloc()
+ -------
+  220628 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  110433 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  110193 calls to shred_free()
+       2 calls to realloc()
+ -------
+  220628 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  110820 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  110580 calls to shred_free()
+       2 calls to realloc()
+ -------
+  221402 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  110820 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  110580 calls to shred_free()
+       2 calls to realloc()
+ -------
+  221402 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  111207 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  110967 calls to shred_free()
+       2 calls to realloc()
+ -------
+  222176 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  111207 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  110967 calls to shred_free()
+       2 calls to realloc()
+ -------
+  222176 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  111594 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  111354 calls to shred_free()
+       2 calls to realloc()
+ -------
+  222950 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  111594 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  111354 calls to shred_free()
+       2 calls to realloc()
+ -------
+  222950 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  111981 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  111741 calls to shred_free()
+       2 calls to realloc()
+ -------
+  223724 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  111981 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  111741 calls to shred_free()
+       2 calls to realloc()
+ -------
+  223724 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  112368 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  112128 calls to shred_free()
+       2 calls to realloc()
+ -------
+  224498 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  112368 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  112128 calls to shred_free()
+       2 calls to realloc()
+ -------
+  224498 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  112755 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  112515 calls to shred_free()
+       2 calls to realloc()
+ -------
+  225272 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  112755 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  112515 calls to shred_free()
+       2 calls to realloc()
+ -------
+  225272 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  113142 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  112902 calls to shred_free()
+       2 calls to realloc()
+ -------
+  226046 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  113142 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  112902 calls to shred_free()
+       2 calls to realloc()
+ -------
+  226046 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  113529 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  113289 calls to shred_free()
+       2 calls to realloc()
+ -------
+  226820 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  113529 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  113289 calls to shred_free()
+       2 calls to realloc()
+ -------
+  226820 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  113916 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  113676 calls to shred_free()
+       2 calls to realloc()
+ -------
+  227594 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  113916 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  113676 calls to shred_free()
+       2 calls to realloc()
+ -------
+  227594 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  114303 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  114063 calls to shred_free()
+       2 calls to realloc()
+ -------
+  228368 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  114303 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  114063 calls to shred_free()
+       2 calls to realloc()
+ -------
+  228368 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  114690 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  114450 calls to shred_free()
+       2 calls to realloc()
+ -------
+  229142 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  114690 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  114450 calls to shred_free()
+       2 calls to realloc()
+ -------
+  229142 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  115077 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  114837 calls to shred_free()
+       2 calls to realloc()
+ -------
+  229916 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  115077 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  114837 calls to shred_free()
+       2 calls to realloc()
+ -------
+  229916 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  115464 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  115224 calls to shred_free()
+       2 calls to realloc()
+ -------
+  230690 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  115464 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  115224 calls to shred_free()
+       2 calls to realloc()
+ -------
+  230690 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  115851 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  115611 calls to shred_free()
+       2 calls to realloc()
+ -------
+  231464 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  115851 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  115611 calls to shred_free()
+       2 calls to realloc()
+ -------
+  231464 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  116238 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  115998 calls to shred_free()
+       2 calls to realloc()
+ -------
+  232238 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  116238 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  115998 calls to shred_free()
+       2 calls to realloc()
+ -------
+  232238 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  116625 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  116385 calls to shred_free()
+       2 calls to realloc()
+ -------
+  233012 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  116625 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  116385 calls to shred_free()
+       2 calls to realloc()
+ -------
+  233012 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  117012 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  116772 calls to shred_free()
+       2 calls to realloc()
+ -------
+  233786 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  117012 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  116772 calls to shred_free()
+       2 calls to realloc()
+ -------
+  233786 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  117399 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  117159 calls to shred_free()
+       2 calls to realloc()
+ -------
+  234560 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  117399 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  117159 calls to shred_free()
+       2 calls to realloc()
+ -------
+  234560 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  117786 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  117546 calls to shred_free()
+       2 calls to realloc()
+ -------
+  235334 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  117786 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  117546 calls to shred_free()
+       2 calls to realloc()
+ -------
+  235334 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  118173 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  117933 calls to shred_free()
+       2 calls to realloc()
+ -------
+  236108 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  118173 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  117933 calls to shred_free()
+       2 calls to realloc()
+ -------
+  236108 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  118560 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  118320 calls to shred_free()
+       2 calls to realloc()
+ -------
+  236882 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  118560 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  118320 calls to shred_free()
+       2 calls to realloc()
+ -------
+  236882 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  118947 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  118707 calls to shred_free()
+       2 calls to realloc()
+ -------
+  237656 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  118947 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  118707 calls to shred_free()
+       2 calls to realloc()
+ -------
+  237656 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  119334 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  119094 calls to shred_free()
+       2 calls to realloc()
+ -------
+  238430 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  119334 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  119094 calls to shred_free()
+       2 calls to realloc()
+ -------
+  238430 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  119721 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  119481 calls to shred_free()
+       2 calls to realloc()
+ -------
+  239204 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  119721 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  119481 calls to shred_free()
+       2 calls to realloc()
+ -------
+  239204 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  120108 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  119868 calls to shred_free()
+       2 calls to realloc()
+ -------
+  239978 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  120108 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  119868 calls to shred_free()
+       2 calls to realloc()
+ -------
+  239978 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  120495 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  120255 calls to shred_free()
+       2 calls to realloc()
+ -------
+  240752 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  120495 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  120255 calls to shred_free()
+       2 calls to realloc()
+ -------
+  240752 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  120882 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  120642 calls to shred_free()
+       2 calls to realloc()
+ -------
+  241526 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  120882 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  120642 calls to shred_free()
+       2 calls to realloc()
+ -------
+  241526 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  121269 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  121029 calls to shred_free()
+       2 calls to realloc()
+ -------
+  242300 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  121269 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  121029 calls to shred_free()
+       2 calls to realloc()
+ -------
+  242300 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  121656 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  121416 calls to shred_free()
+       2 calls to realloc()
+ -------
+  243074 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  121656 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  121416 calls to shred_free()
+       2 calls to realloc()
+ -------
+  243074 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  122043 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  121803 calls to shred_free()
+       2 calls to realloc()
+ -------
+  243848 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  122043 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  121803 calls to shred_free()
+       2 calls to realloc()
+ -------
+  243848 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  122430 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  122190 calls to shred_free()
+       2 calls to realloc()
+ -------
+  244622 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  122430 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  122190 calls to shred_free()
+       2 calls to realloc()
+ -------
+  244622 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  122817 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  122577 calls to shred_free()
+       2 calls to realloc()
+ -------
+  245396 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  122817 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  122577 calls to shred_free()
+       2 calls to realloc()
+ -------
+  245396 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  123204 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  122964 calls to shred_free()
+       2 calls to realloc()
+ -------
+  246170 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  123204 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  122964 calls to shred_free()
+       2 calls to realloc()
+ -------
+  246170 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  123591 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  123351 calls to shred_free()
+       2 calls to realloc()
+ -------
+  246944 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  123591 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  123351 calls to shred_free()
+       2 calls to realloc()
+ -------
+  246944 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  123978 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  123738 calls to shred_free()
+       2 calls to realloc()
+ -------
+  247718 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  123978 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  123738 calls to shred_free()
+       2 calls to realloc()
+ -------
+  247718 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  124349 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  124109 calls to shred_free()
+       2 calls to realloc()
+ -------
+  248460 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  124349 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  124109 calls to shred_free()
+       2 calls to realloc()
+ -------
+  248460 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  124720 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  124480 calls to shred_free()
+       2 calls to realloc()
+ -------
+  249202 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  124720 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  124480 calls to shred_free()
+       2 calls to realloc()
+ -------
+  249202 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  125091 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  124851 calls to shred_free()
+       2 calls to realloc()
+ -------
+  249944 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  125091 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  124851 calls to shred_free()
+       2 calls to realloc()
+ -------
+  249944 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  125462 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  125222 calls to shred_free()
+       2 calls to realloc()
+ -------
+  250686 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  125462 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  125222 calls to shred_free()
+       2 calls to realloc()
+ -------
+  250686 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  125833 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  125593 calls to shred_free()
+       2 calls to realloc()
+ -------
+  251428 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  125833 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  125593 calls to shred_free()
+       2 calls to realloc()
+ -------
+  251428 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  126204 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  125964 calls to shred_free()
+       2 calls to realloc()
+ -------
+  252170 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  126204 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  125964 calls to shred_free()
+       2 calls to realloc()
+ -------
+  252170 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  126575 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  126335 calls to shred_free()
+       2 calls to realloc()
+ -------
+  252912 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  126575 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  126335 calls to shred_free()
+       2 calls to realloc()
+ -------
+  252912 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  126946 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  126706 calls to shred_free()
+       2 calls to realloc()
+ -------
+  253654 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  126946 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  126706 calls to shred_free()
+       2 calls to realloc()
+ -------
+  253654 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  127317 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  127077 calls to shred_free()
+       2 calls to realloc()
+ -------
+  254396 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  127317 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  127077 calls to shred_free()
+       2 calls to realloc()
+ -------
+  254396 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  127688 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  127448 calls to shred_free()
+       2 calls to realloc()
+ -------
+  255138 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  127688 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  127448 calls to shred_free()
+       2 calls to realloc()
+ -------
+  255138 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  128059 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  127819 calls to shred_free()
+       2 calls to realloc()
+ -------
+  255880 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  128059 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  127819 calls to shred_free()
+       2 calls to realloc()
+ -------
+  255880 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  128430 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  128190 calls to shred_free()
+       2 calls to realloc()
+ -------
+  256622 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  128430 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  128190 calls to shred_free()
+       2 calls to realloc()
+ -------
+  256622 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  128801 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  128561 calls to shred_free()
+       2 calls to realloc()
+ -------
+  257364 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  128801 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  128561 calls to shred_free()
+       2 calls to realloc()
+ -------
+  257364 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  129172 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  128932 calls to shred_free()
+       2 calls to realloc()
+ -------
+  258106 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  129172 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  128932 calls to shred_free()
+       2 calls to realloc()
+ -------
+  258106 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  129543 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  129303 calls to shred_free()
+       2 calls to realloc()
+ -------
+  258848 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  129543 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  129303 calls to shred_free()
+       2 calls to realloc()
+ -------
+  258848 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  129914 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  129674 calls to shred_free()
+       2 calls to realloc()
+ -------
+  259590 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  129914 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  129674 calls to shred_free()
+       2 calls to realloc()
+ -------
+  259590 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  130285 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  130045 calls to shred_free()
+       2 calls to realloc()
+ -------
+  260332 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  130285 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  130045 calls to shred_free()
+       2 calls to realloc()
+ -------
+  260332 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  130656 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  130416 calls to shred_free()
+       2 calls to realloc()
+ -------
+  261074 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  130656 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  130416 calls to shred_free()
+       2 calls to realloc()
+ -------
+  261074 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  131027 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  130787 calls to shred_free()
+       2 calls to realloc()
+ -------
+  261816 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  131027 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  130787 calls to shred_free()
+       2 calls to realloc()
+ -------
+  261816 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  131398 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  131158 calls to shred_free()
+       2 calls to realloc()
+ -------
+  262558 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  131398 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  131158 calls to shred_free()
+       2 calls to realloc()
+ -------
+  262558 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  131769 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  131529 calls to shred_free()
+       2 calls to realloc()
+ -------
+  263300 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  131769 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  131529 calls to shred_free()
+       2 calls to realloc()
+ -------
+  263300 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  132140 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  131900 calls to shred_free()
+       2 calls to realloc()
+ -------
+  264042 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  132140 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  131900 calls to shred_free()
+       2 calls to realloc()
+ -------
+  264042 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  132511 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  132271 calls to shred_free()
+       2 calls to realloc()
+ -------
+  264784 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  132511 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  132271 calls to shred_free()
+       2 calls to realloc()
+ -------
+  264784 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  132882 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  132642 calls to shred_free()
+       2 calls to realloc()
+ -------
+  265526 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  132882 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  132642 calls to shred_free()
+       2 calls to realloc()
+ -------
+  265526 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  133253 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  133013 calls to shred_free()
+       2 calls to realloc()
+ -------
+  266268 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  133253 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  133013 calls to shred_free()
+       2 calls to realloc()
+ -------
+  266268 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  133624 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  133384 calls to shred_free()
+       2 calls to realloc()
+ -------
+  267010 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  133624 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  133384 calls to shred_free()
+       2 calls to realloc()
+ -------
+  267010 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  133995 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  133755 calls to shred_free()
+       2 calls to realloc()
+ -------
+  267752 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  133995 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  133755 calls to shred_free()
+       2 calls to realloc()
+ -------
+  267752 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  134366 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  134126 calls to shred_free()
+       2 calls to realloc()
+ -------
+  268494 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  134366 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  134126 calls to shred_free()
+       2 calls to realloc()
+ -------
+  268494 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  134737 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  134497 calls to shred_free()
+       2 calls to realloc()
+ -------
+  269236 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  134737 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  134497 calls to shred_free()
+       2 calls to realloc()
+ -------
+  269236 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  135108 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  134868 calls to shred_free()
+       2 calls to realloc()
+ -------
+  269978 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  135108 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  134868 calls to shred_free()
+       2 calls to realloc()
+ -------
+  269978 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  135479 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  135239 calls to shred_free()
+       2 calls to realloc()
+ -------
+  270720 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  135479 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  135239 calls to shred_free()
+       2 calls to realloc()
+ -------
+  270720 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  135850 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  135610 calls to shred_free()
+       2 calls to realloc()
+ -------
+  271462 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  135850 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  135610 calls to shred_free()
+       2 calls to realloc()
+ -------
+  271462 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  136221 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  135981 calls to shred_free()
+       2 calls to realloc()
+ -------
+  272204 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  136221 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  135981 calls to shred_free()
+       2 calls to realloc()
+ -------
+  272204 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  136592 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  136352 calls to shred_free()
+       2 calls to realloc()
+ -------
+  272946 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  136592 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  136352 calls to shred_free()
+       2 calls to realloc()
+ -------
+  272946 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  136963 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  136723 calls to shred_free()
+       2 calls to realloc()
+ -------
+  273688 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  136963 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  136723 calls to shred_free()
+       2 calls to realloc()
+ -------
+  273688 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  137334 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  137094 calls to shred_free()
+       2 calls to realloc()
+ -------
+  274430 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  137334 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  137094 calls to shred_free()
+       2 calls to realloc()
+ -------
+  274430 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  137705 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  137465 calls to shred_free()
+       2 calls to realloc()
+ -------
+  275172 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  137705 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  137465 calls to shred_free()
+       2 calls to realloc()
+ -------
+  275172 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  138076 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  137836 calls to shred_free()
+       2 calls to realloc()
+ -------
+  275914 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  138076 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  137836 calls to shred_free()
+       2 calls to realloc()
+ -------
+  275914 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  138447 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  138207 calls to shred_free()
+       2 calls to realloc()
+ -------
+  276656 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  138447 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  138207 calls to shred_free()
+       2 calls to realloc()
+ -------
+  276656 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  138818 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  138578 calls to shred_free()
+       2 calls to realloc()
+ -------
+  277398 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  138818 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  138578 calls to shred_free()
+       2 calls to realloc()
+ -------
+  277398 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  139189 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  138949 calls to shred_free()
+       2 calls to realloc()
+ -------
+  278140 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  139189 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  138949 calls to shred_free()
+       2 calls to realloc()
+ -------
+  278140 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  139560 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  139320 calls to shred_free()
+       2 calls to realloc()
+ -------
+  278882 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  139560 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  139320 calls to shred_free()
+       2 calls to realloc()
+ -------
+  278882 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  139931 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  139691 calls to shred_free()
+       2 calls to realloc()
+ -------
+  279624 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  139931 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  139691 calls to shred_free()
+       2 calls to realloc()
+ -------
+  279624 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  140302 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  140062 calls to shred_free()
+       2 calls to realloc()
+ -------
+  280366 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  140302 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  140062 calls to shred_free()
+       2 calls to realloc()
+ -------
+  280366 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  140673 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  140433 calls to shred_free()
+       2 calls to realloc()
+ -------
+  281108 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  140673 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  140433 calls to shred_free()
+       2 calls to realloc()
+ -------
+  281108 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  141044 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  140804 calls to shred_free()
+       2 calls to realloc()
+ -------
+  281850 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  141044 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  140804 calls to shred_free()
+       2 calls to realloc()
+ -------
+  281850 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  141415 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  141175 calls to shred_free()
+       2 calls to realloc()
+ -------
+  282592 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  141415 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  141175 calls to shred_free()
+       2 calls to realloc()
+ -------
+  282592 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  141786 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  141546 calls to shred_free()
+       2 calls to realloc()
+ -------
+  283334 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  141786 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  141546 calls to shred_free()
+       2 calls to realloc()
+ -------
+  283334 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  142157 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  141917 calls to shred_free()
+       2 calls to realloc()
+ -------
+  284076 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  142157 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  141917 calls to shred_free()
+       2 calls to realloc()
+ -------
+  284076 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  142528 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  142288 calls to shred_free()
+       2 calls to realloc()
+ -------
+  284818 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  142528 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  142288 calls to shred_free()
+       2 calls to realloc()
+ -------
+  284818 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  142899 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  142659 calls to shred_free()
+       2 calls to realloc()
+ -------
+  285560 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  142899 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  142659 calls to shred_free()
+       2 calls to realloc()
+ -------
+  285560 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  143270 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  143030 calls to shred_free()
+       2 calls to realloc()
+ -------
+  286302 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  143270 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  143030 calls to shred_free()
+       2 calls to realloc()
+ -------
+  286302 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  143641 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  143401 calls to shred_free()
+       2 calls to realloc()
+ -------
+  287044 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  143641 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  143401 calls to shred_free()
+       2 calls to realloc()
+ -------
+  287044 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  144012 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  143772 calls to shred_free()
+       2 calls to realloc()
+ -------
+  287786 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  144012 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  143772 calls to shred_free()
+       2 calls to realloc()
+ -------
+  287786 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  144383 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  144143 calls to shred_free()
+       2 calls to realloc()
+ -------
+  288528 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  144383 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  144143 calls to shred_free()
+       2 calls to realloc()
+ -------
+  288528 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  144754 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  144514 calls to shred_free()
+       2 calls to realloc()
+ -------
+  289270 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  144754 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  144514 calls to shred_free()
+       2 calls to realloc()
+ -------
+  289270 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  145125 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  144885 calls to shred_free()
+       2 calls to realloc()
+ -------
+  290012 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  145125 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  144885 calls to shred_free()
+       2 calls to realloc()
+ -------
+  290012 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  145496 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  145256 calls to shred_free()
+       2 calls to realloc()
+ -------
+  290754 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  145496 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  145256 calls to shred_free()
+       2 calls to realloc()
+ -------
+  290754 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  145867 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  145627 calls to shred_free()
+       2 calls to realloc()
+ -------
+  291496 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  145867 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  145627 calls to shred_free()
+       2 calls to realloc()
+ -------
+  291496 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  146238 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  145998 calls to shred_free()
+       2 calls to realloc()
+ -------
+  292238 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  146238 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  145998 calls to shred_free()
+       2 calls to realloc()
+ -------
+  292238 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  146609 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  146369 calls to shred_free()
+       2 calls to realloc()
+ -------
+  292980 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  146609 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  146369 calls to shred_free()
+       2 calls to realloc()
+ -------
+  292980 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  146980 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  146740 calls to shred_free()
+       2 calls to realloc()
+ -------
+  293722 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  146980 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  146740 calls to shred_free()
+       2 calls to realloc()
+ -------
+  293722 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  147351 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  147111 calls to shred_free()
+       2 calls to realloc()
+ -------
+  294464 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  147351 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  147111 calls to shred_free()
+       2 calls to realloc()
+ -------
+  294464 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  147722 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  147482 calls to shred_free()
+       2 calls to realloc()
+ -------
+  295206 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  147722 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  147482 calls to shred_free()
+       2 calls to realloc()
+ -------
+  295206 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  148093 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  147853 calls to shred_free()
+       2 calls to realloc()
+ -------
+  295948 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  148093 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  147853 calls to shred_free()
+       2 calls to realloc()
+ -------
+  295948 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  148464 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  148224 calls to shred_free()
+       2 calls to realloc()
+ -------
+  296690 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  148464 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  148224 calls to shred_free()
+       2 calls to realloc()
+ -------
+  296690 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  148835 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  148595 calls to shred_free()
+       2 calls to realloc()
+ -------
+  297432 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  148835 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  148595 calls to shred_free()
+       2 calls to realloc()
+ -------
+  297432 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  149206 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  148966 calls to shred_free()
+       2 calls to realloc()
+ -------
+  298174 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  149206 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  148966 calls to shred_free()
+       2 calls to realloc()
+ -------
+  298174 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  149577 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  149337 calls to shred_free()
+       2 calls to realloc()
+ -------
+  298916 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  149577 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  149337 calls to shred_free()
+       2 calls to realloc()
+ -------
+  298916 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  149948 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  149708 calls to shred_free()
+       2 calls to realloc()
+ -------
+  299658 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  149948 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  149708 calls to shred_free()
+       2 calls to realloc()
+ -------
+  299658 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  150319 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  150079 calls to shred_free()
+       2 calls to realloc()
+ -------
+  300400 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  150319 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  150079 calls to shred_free()
+       2 calls to realloc()
+ -------
+  300400 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  150690 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  150450 calls to shred_free()
+       2 calls to realloc()
+ -------
+  301142 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  150690 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  150450 calls to shred_free()
+       2 calls to realloc()
+ -------
+  301142 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  151061 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  150821 calls to shred_free()
+       2 calls to realloc()
+ -------
+  301884 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  151061 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  150821 calls to shred_free()
+       2 calls to realloc()
+ -------
+  301884 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  151432 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  151192 calls to shred_free()
+       2 calls to realloc()
+ -------
+  302626 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  151432 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  151192 calls to shred_free()
+       2 calls to realloc()
+ -------
+  302626 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  151803 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  151563 calls to shred_free()
+       2 calls to realloc()
+ -------
+  303368 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  151803 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  151563 calls to shred_free()
+       2 calls to realloc()
+ -------
+  303368 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  152174 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  151934 calls to shred_free()
+       2 calls to realloc()
+ -------
+  304110 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  152174 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  151934 calls to shred_free()
+       2 calls to realloc()
+ -------
+  304110 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  152545 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  152305 calls to shred_free()
+       2 calls to realloc()
+ -------
+  304852 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  152545 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  152305 calls to shred_free()
+       2 calls to realloc()
+ -------
+  304852 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  152916 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  152676 calls to shred_free()
+       2 calls to realloc()
+ -------
+  305594 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  152916 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  152676 calls to shred_free()
+       2 calls to realloc()
+ -------
+  305594 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  153287 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  153047 calls to shred_free()
+       2 calls to realloc()
+ -------
+  306336 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  153287 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  153047 calls to shred_free()
+       2 calls to realloc()
+ -------
+  306336 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  153658 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  153418 calls to shred_free()
+       2 calls to realloc()
+ -------
+  307078 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  153658 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  153418 calls to shred_free()
+       2 calls to realloc()
+ -------
+  307078 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  154029 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  153789 calls to shred_free()
+       2 calls to realloc()
+ -------
+  307820 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  154029 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  153789 calls to shred_free()
+       2 calls to realloc()
+ -------
+  307820 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  154400 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  154160 calls to shred_free()
+       2 calls to realloc()
+ -------
+  308562 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  154400 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  154160 calls to shred_free()
+       2 calls to realloc()
+ -------
+  308562 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  154771 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  154531 calls to shred_free()
+       2 calls to realloc()
+ -------
+  309304 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  154771 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  154531 calls to shred_free()
+       2 calls to realloc()
+ -------
+  309304 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  155142 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  154902 calls to shred_free()
+       2 calls to realloc()
+ -------
+  310046 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  155142 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  154902 calls to shred_free()
+       2 calls to realloc()
+ -------
+  310046 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  155513 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  155273 calls to shred_free()
+       2 calls to realloc()
+ -------
+  310788 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  155513 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  155273 calls to shred_free()
+       2 calls to realloc()
+ -------
+  310788 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  155884 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  155644 calls to shred_free()
+       2 calls to realloc()
+ -------
+  311530 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  155884 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  155644 calls to shred_free()
+       2 calls to realloc()
+ -------
+  311530 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  156255 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  156015 calls to shred_free()
+       2 calls to realloc()
+ -------
+  312272 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  156255 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  156015 calls to shred_free()
+       2 calls to realloc()
+ -------
+  312272 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  156626 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  156386 calls to shred_free()
+       2 calls to realloc()
+ -------
+  313014 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  156626 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  156386 calls to shred_free()
+       2 calls to realloc()
+ -------
+  313014 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  156997 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  156757 calls to shred_free()
+       2 calls to realloc()
+ -------
+  313756 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  156997 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  156757 calls to shred_free()
+       2 calls to realloc()
+ -------
+  313756 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  157368 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  157128 calls to shred_free()
+       2 calls to realloc()
+ -------
+  314498 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  157368 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  157128 calls to shred_free()
+       2 calls to realloc()
+ -------
+  314498 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  157739 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  157499 calls to shred_free()
+       2 calls to realloc()
+ -------
+  315240 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  157739 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  157499 calls to shred_free()
+       2 calls to realloc()
+ -------
+  315240 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  158110 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  157870 calls to shred_free()
+       2 calls to realloc()
+ -------
+  315982 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  158110 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  157870 calls to shred_free()
+       2 calls to realloc()
+ -------
+  315982 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  158481 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  158241 calls to shred_free()
+       2 calls to realloc()
+ -------
+  316724 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  158481 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  158241 calls to shred_free()
+       2 calls to realloc()
+ -------
+  316724 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  158852 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  158612 calls to shred_free()
+       2 calls to realloc()
+ -------
+  317466 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  158852 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  158612 calls to shred_free()
+       2 calls to realloc()
+ -------
+  317466 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  159223 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  158983 calls to shred_free()
+       2 calls to realloc()
+ -------
+  318208 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  159223 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  158983 calls to shred_free()
+       2 calls to realloc()
+ -------
+  318208 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  159594 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  159354 calls to shred_free()
+       2 calls to realloc()
+ -------
+  318950 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  159594 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  159354 calls to shred_free()
+       2 calls to realloc()
+ -------
+  318950 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  159965 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  159725 calls to shred_free()
+       2 calls to realloc()
+ -------
+  319692 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  159965 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  159725 calls to shred_free()
+       2 calls to realloc()
+ -------
+  319692 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  160336 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  160096 calls to shred_free()
+       2 calls to realloc()
+ -------
+  320434 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  160336 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  160096 calls to shred_free()
+       2 calls to realloc()
+ -------
+  320434 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  160707 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  160467 calls to shred_free()
+       2 calls to realloc()
+ -------
+  321176 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  160707 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  160467 calls to shred_free()
+       2 calls to realloc()
+ -------
+  321176 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  161078 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  160838 calls to shred_free()
+       2 calls to realloc()
+ -------
+  321918 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  161078 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  160838 calls to shred_free()
+       2 calls to realloc()
+ -------
+  321918 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  161449 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  161209 calls to shred_free()
+       2 calls to realloc()
+ -------
+  322660 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  161449 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  161209 calls to shred_free()
+       2 calls to realloc()
+ -------
+  322660 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  161820 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  161580 calls to shred_free()
+       2 calls to realloc()
+ -------
+  323402 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  161820 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  161580 calls to shred_free()
+       2 calls to realloc()
+ -------
+  323402 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  162191 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  161951 calls to shred_free()
+       2 calls to realloc()
+ -------
+  324144 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  162191 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  161951 calls to shred_free()
+       2 calls to realloc()
+ -------
+  324144 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  162562 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  162322 calls to shred_free()
+       2 calls to realloc()
+ -------
+  324886 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  162562 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  162322 calls to shred_free()
+       2 calls to realloc()
+ -------
+  324886 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  162933 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  162693 calls to shred_free()
+       2 calls to realloc()
+ -------
+  325628 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  162933 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  162693 calls to shred_free()
+       2 calls to realloc()
+ -------
+  325628 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  163304 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  163064 calls to shred_free()
+       2 calls to realloc()
+ -------
+  326370 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  163304 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  163064 calls to shred_free()
+       2 calls to realloc()
+ -------
+  326370 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  163659 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  163419 calls to shred_free()
+       2 calls to realloc()
+ -------
+  327080 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  163659 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  163419 calls to shred_free()
+       2 calls to realloc()
+ -------
+  327080 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  164016 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  163776 calls to shred_free()
+       2 calls to realloc()
+ -------
+  327794 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  164016 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  163776 calls to shred_free()
+       2 calls to realloc()
+ -------
+  327794 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  164373 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  164133 calls to shred_free()
+       2 calls to realloc()
+ -------
+  328508 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  164373 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  164133 calls to shred_free()
+       2 calls to realloc()
+ -------
+  328508 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  164730 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  164490 calls to shred_free()
+       2 calls to realloc()
+ -------
+  329222 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  164730 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  164490 calls to shred_free()
+       2 calls to realloc()
+ -------
+  329222 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  165087 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  164847 calls to shred_free()
+       2 calls to realloc()
+ -------
+  329936 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  165087 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  164847 calls to shred_free()
+       2 calls to realloc()
+ -------
+  329936 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  165444 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  165204 calls to shred_free()
+       2 calls to realloc()
+ -------
+  330650 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  165444 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  165204 calls to shred_free()
+       2 calls to realloc()
+ -------
+  330650 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  165801 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  165561 calls to shred_free()
+       2 calls to realloc()
+ -------
+  331364 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  165801 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  165561 calls to shred_free()
+       2 calls to realloc()
+ -------
+  331364 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  166158 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  165918 calls to shred_free()
+       2 calls to realloc()
+ -------
+  332078 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  166158 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  165918 calls to shred_free()
+       2 calls to realloc()
+ -------
+  332078 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  166515 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  166275 calls to shred_free()
+       2 calls to realloc()
+ -------
+  332792 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  166515 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  166275 calls to shred_free()
+       2 calls to realloc()
+ -------
+  332792 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  166872 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  166632 calls to shred_free()
+       2 calls to realloc()
+ -------
+  333506 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  166872 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  166632 calls to shred_free()
+       2 calls to realloc()
+ -------
+  333506 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  167229 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  166989 calls to shred_free()
+       2 calls to realloc()
+ -------
+  334220 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  167229 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  166989 calls to shred_free()
+       2 calls to realloc()
+ -------
+  334220 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  167586 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  167346 calls to shred_free()
+       2 calls to realloc()
+ -------
+  334934 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  167586 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  167346 calls to shred_free()
+       2 calls to realloc()
+ -------
+  334934 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  167943 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  167703 calls to shred_free()
+       2 calls to realloc()
+ -------
+  335648 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  167943 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  167703 calls to shred_free()
+       2 calls to realloc()
+ -------
+  335648 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  168300 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  168060 calls to shred_free()
+       2 calls to realloc()
+ -------
+  336362 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  168300 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  168060 calls to shred_free()
+       2 calls to realloc()
+ -------
+  336362 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  168657 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  168417 calls to shred_free()
+       2 calls to realloc()
+ -------
+  337076 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  168657 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  168417 calls to shred_free()
+       2 calls to realloc()
+ -------
+  337076 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  169014 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  168774 calls to shred_free()
+       2 calls to realloc()
+ -------
+  337790 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  169014 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  168774 calls to shred_free()
+       2 calls to realloc()
+ -------
+  337790 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  169371 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  169131 calls to shred_free()
+       2 calls to realloc()
+ -------
+  338504 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  169371 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  169131 calls to shred_free()
+       2 calls to realloc()
+ -------
+  338504 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  169728 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  169488 calls to shred_free()
+       2 calls to realloc()
+ -------
+  339218 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  169728 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  169488 calls to shred_free()
+       2 calls to realloc()
+ -------
+  339218 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  170085 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  169845 calls to shred_free()
+       2 calls to realloc()
+ -------
+  339932 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  170085 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  169845 calls to shred_free()
+       2 calls to realloc()
+ -------
+  339932 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  170442 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  170202 calls to shred_free()
+       2 calls to realloc()
+ -------
+  340646 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  170442 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  170202 calls to shred_free()
+       2 calls to realloc()
+ -------
+  340646 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  170799 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  170559 calls to shred_free()
+       2 calls to realloc()
+ -------
+  341360 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  170799 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  170559 calls to shred_free()
+       2 calls to realloc()
+ -------
+  341360 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  171156 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  170916 calls to shred_free()
+       2 calls to realloc()
+ -------
+  342074 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  171156 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  170916 calls to shred_free()
+       2 calls to realloc()
+ -------
+  342074 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  171513 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  171273 calls to shred_free()
+       2 calls to realloc()
+ -------
+  342788 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  171513 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  171273 calls to shred_free()
+       2 calls to realloc()
+ -------
+  342788 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  171870 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  171630 calls to shred_free()
+       2 calls to realloc()
+ -------
+  343502 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  171870 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  171630 calls to shred_free()
+       2 calls to realloc()
+ -------
+  343502 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  172227 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  171987 calls to shred_free()
+       2 calls to realloc()
+ -------
+  344216 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  172227 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  171987 calls to shred_free()
+       2 calls to realloc()
+ -------
+  344216 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  172584 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  172344 calls to shred_free()
+       2 calls to realloc()
+ -------
+  344930 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  172584 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  172344 calls to shred_free()
+       2 calls to realloc()
+ -------
+  344930 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  172941 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  172701 calls to shred_free()
+       2 calls to realloc()
+ -------
+  345644 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  172941 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  172701 calls to shred_free()
+       2 calls to realloc()
+ -------
+  345644 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  173298 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  173058 calls to shred_free()
+       2 calls to realloc()
+ -------
+  346358 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  173298 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  173058 calls to shred_free()
+       2 calls to realloc()
+ -------
+  346358 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  173655 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  173415 calls to shred_free()
+       2 calls to realloc()
+ -------
+  347072 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  173655 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  173415 calls to shred_free()
+       2 calls to realloc()
+ -------
+  347072 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  174012 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  173772 calls to shred_free()
+       2 calls to realloc()
+ -------
+  347786 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  174012 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  173772 calls to shred_free()
+       2 calls to realloc()
+ -------
+  347786 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  174369 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  174129 calls to shred_free()
+       2 calls to realloc()
+ -------
+  348500 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  174369 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  174129 calls to shred_free()
+       2 calls to realloc()
+ -------
+  348500 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  174726 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  174486 calls to shred_free()
+       2 calls to realloc()
+ -------
+  349214 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  174726 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  174486 calls to shred_free()
+       2 calls to realloc()
+ -------
+  349214 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  175083 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  174843 calls to shred_free()
+       2 calls to realloc()
+ -------
+  349928 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  175083 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  174843 calls to shred_free()
+       2 calls to realloc()
+ -------
+  349928 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  175440 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  175200 calls to shred_free()
+       2 calls to realloc()
+ -------
+  350642 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  175440 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  175200 calls to shred_free()
+       2 calls to realloc()
+ -------
+  350642 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  175797 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  175557 calls to shred_free()
+       2 calls to realloc()
+ -------
+  351356 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  175797 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  175557 calls to shred_free()
+       2 calls to realloc()
+ -------
+  351356 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  176154 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  175914 calls to shred_free()
+       2 calls to realloc()
+ -------
+  352070 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  176154 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  175914 calls to shred_free()
+       2 calls to realloc()
+ -------
+  352070 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  176511 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  176271 calls to shred_free()
+       2 calls to realloc()
+ -------
+  352784 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  176511 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  176271 calls to shred_free()
+       2 calls to realloc()
+ -------
+  352784 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  176868 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  176628 calls to shred_free()
+       2 calls to realloc()
+ -------
+  353498 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  176868 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  176628 calls to shred_free()
+       2 calls to realloc()
+ -------
+  353498 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  177225 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  176985 calls to shred_free()
+       2 calls to realloc()
+ -------
+  354212 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  177225 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  176985 calls to shred_free()
+       2 calls to realloc()
+ -------
+  354212 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  177582 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  177342 calls to shred_free()
+       2 calls to realloc()
+ -------
+  354926 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  177582 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  177342 calls to shred_free()
+       2 calls to realloc()
+ -------
+  354926 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  177939 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  177699 calls to shred_free()
+       2 calls to realloc()
+ -------
+  355640 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  177939 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  177699 calls to shred_free()
+       2 calls to realloc()
+ -------
+  355640 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  178296 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  178056 calls to shred_free()
+       2 calls to realloc()
+ -------
+  356354 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  178296 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  178056 calls to shred_free()
+       2 calls to realloc()
+ -------
+  356354 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  178653 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  178413 calls to shred_free()
+       2 calls to realloc()
+ -------
+  357068 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  178653 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  178413 calls to shred_free()
+       2 calls to realloc()
+ -------
+  357068 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  179010 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  178770 calls to shred_free()
+       2 calls to realloc()
+ -------
+  357782 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  179010 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  178770 calls to shred_free()
+       2 calls to realloc()
+ -------
+  357782 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  179367 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  179127 calls to shred_free()
+       2 calls to realloc()
+ -------
+  358496 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  179367 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  179127 calls to shred_free()
+       2 calls to realloc()
+ -------
+  358496 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  179724 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  179484 calls to shred_free()
+       2 calls to realloc()
+ -------
+  359210 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  179724 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  179484 calls to shred_free()
+       2 calls to realloc()
+ -------
+  359210 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  180081 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  179841 calls to shred_free()
+       2 calls to realloc()
+ -------
+  359924 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  180081 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  179841 calls to shred_free()
+       2 calls to realloc()
+ -------
+  359924 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  180438 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  180198 calls to shred_free()
+       2 calls to realloc()
+ -------
+  360638 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  180438 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  180198 calls to shred_free()
+       2 calls to realloc()
+ -------
+  360638 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  180795 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  180555 calls to shred_free()
+       2 calls to realloc()
+ -------
+  361352 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  180795 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  180555 calls to shred_free()
+       2 calls to realloc()
+ -------
+  361352 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  181152 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  180912 calls to shred_free()
+       2 calls to realloc()
+ -------
+  362066 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  181152 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  180912 calls to shred_free()
+       2 calls to realloc()
+ -------
+  362066 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  181509 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  181269 calls to shred_free()
+       2 calls to realloc()
+ -------
+  362780 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  181509 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  181269 calls to shred_free()
+       2 calls to realloc()
+ -------
+  362780 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  181866 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  181626 calls to shred_free()
+       2 calls to realloc()
+ -------
+  363494 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  181866 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  181626 calls to shred_free()
+       2 calls to realloc()
+ -------
+  363494 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  182223 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  181983 calls to shred_free()
+       2 calls to realloc()
+ -------
+  364208 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  182223 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  181983 calls to shred_free()
+       2 calls to realloc()
+ -------
+  364208 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  182580 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  182340 calls to shred_free()
+       2 calls to realloc()
+ -------
+  364922 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  182580 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  182340 calls to shred_free()
+       2 calls to realloc()
+ -------
+  364922 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  182937 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  182697 calls to shred_free()
+       2 calls to realloc()
+ -------
+  365636 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  182937 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  182697 calls to shred_free()
+       2 calls to realloc()
+ -------
+  365636 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  183294 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  183054 calls to shred_free()
+       2 calls to realloc()
+ -------
+  366350 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  183294 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  183054 calls to shred_free()
+       2 calls to realloc()
+ -------
+  366350 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  183651 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  183411 calls to shred_free()
+       2 calls to realloc()
+ -------
+  367064 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  183651 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  183411 calls to shred_free()
+       2 calls to realloc()
+ -------
+  367064 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  184008 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  183768 calls to shred_free()
+       2 calls to realloc()
+ -------
+  367778 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  184008 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  183768 calls to shred_free()
+       2 calls to realloc()
+ -------
+  367778 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  184365 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  184125 calls to shred_free()
+       2 calls to realloc()
+ -------
+  368492 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  184365 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  184125 calls to shred_free()
+       2 calls to realloc()
+ -------
+  368492 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  184722 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  184482 calls to shred_free()
+       2 calls to realloc()
+ -------
+  369206 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  184722 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  184482 calls to shred_free()
+       2 calls to realloc()
+ -------
+  369206 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  185079 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  184839 calls to shred_free()
+       2 calls to realloc()
+ -------
+  369920 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  185079 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  184839 calls to shred_free()
+       2 calls to realloc()
+ -------
+  369920 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  185436 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  185196 calls to shred_free()
+       2 calls to realloc()
+ -------
+  370634 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  185436 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  185196 calls to shred_free()
+       2 calls to realloc()
+ -------
+  370634 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  185793 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  185553 calls to shred_free()
+       2 calls to realloc()
+ -------
+  371348 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  185793 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  185553 calls to shred_free()
+       2 calls to realloc()
+ -------
+  371348 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  186150 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  185910 calls to shred_free()
+       2 calls to realloc()
+ -------
+  372062 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  186150 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  185910 calls to shred_free()
+       2 calls to realloc()
+ -------
+  372062 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  186507 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  186267 calls to shred_free()
+       2 calls to realloc()
+ -------
+  372776 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  186507 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  186267 calls to shred_free()
+       2 calls to realloc()
+ -------
+  372776 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  186864 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  186624 calls to shred_free()
+       2 calls to realloc()
+ -------
+  373490 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  186864 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  186624 calls to shred_free()
+       2 calls to realloc()
+ -------
+  373490 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  187221 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  186981 calls to shred_free()
+       2 calls to realloc()
+ -------
+  374204 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  187221 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  186981 calls to shred_free()
+       2 calls to realloc()
+ -------
+  374204 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  187578 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  187338 calls to shred_free()
+       2 calls to realloc()
+ -------
+  374918 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  187578 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  187338 calls to shred_free()
+       2 calls to realloc()
+ -------
+  374918 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  187935 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  187695 calls to shred_free()
+       2 calls to realloc()
+ -------
+  375632 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  187935 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  187695 calls to shred_free()
+       2 calls to realloc()
+ -------
+  375632 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  188292 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  188052 calls to shred_free()
+       2 calls to realloc()
+ -------
+  376346 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  188292 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  188052 calls to shred_free()
+       2 calls to realloc()
+ -------
+  376346 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  188649 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  188409 calls to shred_free()
+       2 calls to realloc()
+ -------
+  377060 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  188649 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  188409 calls to shred_free()
+       2 calls to realloc()
+ -------
+  377060 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  189006 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  188766 calls to shred_free()
+       2 calls to realloc()
+ -------
+  377774 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  189006 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  188766 calls to shred_free()
+       2 calls to realloc()
+ -------
+  377774 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  189363 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  189123 calls to shred_free()
+       2 calls to realloc()
+ -------
+  378488 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  189363 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  189123 calls to shred_free()
+       2 calls to realloc()
+ -------
+  378488 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  189720 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  189480 calls to shred_free()
+       2 calls to realloc()
+ -------
+  379202 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  189720 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  189480 calls to shred_free()
+       2 calls to realloc()
+ -------
+  379202 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  190077 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  189837 calls to shred_free()
+       2 calls to realloc()
+ -------
+  379916 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  190077 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  189837 calls to shred_free()
+       2 calls to realloc()
+ -------
+  379916 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  190434 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  190194 calls to shred_free()
+       2 calls to realloc()
+ -------
+  380630 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  190434 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  190194 calls to shred_free()
+       2 calls to realloc()
+ -------
+  380630 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  190791 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  190551 calls to shred_free()
+       2 calls to realloc()
+ -------
+  381344 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  190791 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  190551 calls to shred_free()
+       2 calls to realloc()
+ -------
+  381344 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  191148 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  190908 calls to shred_free()
+       2 calls to realloc()
+ -------
+  382058 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  191148 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  190908 calls to shred_free()
+       2 calls to realloc()
+ -------
+  382058 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  191505 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  191265 calls to shred_free()
+       2 calls to realloc()
+ -------
+  382772 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  191505 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  191265 calls to shred_free()
+       2 calls to realloc()
+ -------
+  382772 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  191862 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  191622 calls to shred_free()
+       2 calls to realloc()
+ -------
+  383486 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  191862 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  191622 calls to shred_free()
+       2 calls to realloc()
+ -------
+  383486 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  192219 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  191979 calls to shred_free()
+       2 calls to realloc()
+ -------
+  384200 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  192219 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  191979 calls to shred_free()
+       2 calls to realloc()
+ -------
+  384200 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  192576 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  192336 calls to shred_free()
+       2 calls to realloc()
+ -------
+  384914 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  192576 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  192336 calls to shred_free()
+       2 calls to realloc()
+ -------
+  384914 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  192933 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  192693 calls to shred_free()
+       2 calls to realloc()
+ -------
+  385628 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  192933 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  192693 calls to shred_free()
+       2 calls to realloc()
+ -------
+  385628 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  193290 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  193050 calls to shred_free()
+       2 calls to realloc()
+ -------
+  386342 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  193290 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  193050 calls to shred_free()
+       2 calls to realloc()
+ -------
+  386342 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  193647 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  193407 calls to shred_free()
+       2 calls to realloc()
+ -------
+  387056 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  193647 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  193407 calls to shred_free()
+       2 calls to realloc()
+ -------
+  387056 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  194004 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  193764 calls to shred_free()
+       2 calls to realloc()
+ -------
+  387770 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  194004 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  193764 calls to shred_free()
+       2 calls to realloc()
+ -------
+  387770 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  194361 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  194121 calls to shred_free()
+       2 calls to realloc()
+ -------
+  388484 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  194361 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  194121 calls to shred_free()
+       2 calls to realloc()
+ -------
+  388484 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  194718 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  194478 calls to shred_free()
+       2 calls to realloc()
+ -------
+  389198 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  194718 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  194478 calls to shred_free()
+       2 calls to realloc()
+ -------
+  389198 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  195075 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  194835 calls to shred_free()
+       2 calls to realloc()
+ -------
+  389912 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  195075 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  194835 calls to shred_free()
+       2 calls to realloc()
+ -------
+  389912 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  195432 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  195192 calls to shred_free()
+       2 calls to realloc()
+ -------
+  390626 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  195432 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  195192 calls to shred_free()
+       2 calls to realloc()
+ -------
+  390626 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  195789 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  195549 calls to shred_free()
+       2 calls to realloc()
+ -------
+  391340 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  195789 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  195549 calls to shred_free()
+       2 calls to realloc()
+ -------
+  391340 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  196146 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  195906 calls to shred_free()
+       2 calls to realloc()
+ -------
+  392054 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  196146 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  195906 calls to shred_free()
+       2 calls to realloc()
+ -------
+  392054 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  196519 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  196279 calls to shred_free()
+       2 calls to realloc()
+ -------
+  392800 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  196519 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  196279 calls to shred_free()
+       2 calls to realloc()
+ -------
+  392800 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  196891 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  196651 calls to shred_free()
+       2 calls to realloc()
+ -------
+  393544 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  196891 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  196651 calls to shred_free()
+       2 calls to realloc()
+ -------
+  393544 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  197263 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  197023 calls to shred_free()
+       2 calls to realloc()
+ -------
+  394288 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  197263 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  197023 calls to shred_free()
+       2 calls to realloc()
+ -------
+  394288 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  197635 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  197395 calls to shred_free()
+       2 calls to realloc()
+ -------
+  395032 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  197635 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  197395 calls to shred_free()
+       2 calls to realloc()
+ -------
+  395032 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  198007 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  197767 calls to shred_free()
+       2 calls to realloc()
+ -------
+  395776 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  198007 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  197767 calls to shred_free()
+       2 calls to realloc()
+ -------
+  395776 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  198379 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  198139 calls to shred_free()
+       2 calls to realloc()
+ -------
+  396520 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  198379 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  198139 calls to shred_free()
+       2 calls to realloc()
+ -------
+  396520 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  198751 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  198511 calls to shred_free()
+       2 calls to realloc()
+ -------
+  397264 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  198751 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  198511 calls to shred_free()
+       2 calls to realloc()
+ -------
+  397264 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  199123 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  198883 calls to shred_free()
+       2 calls to realloc()
+ -------
+  398008 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  199123 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  198883 calls to shred_free()
+       2 calls to realloc()
+ -------
+  398008 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  199495 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  199255 calls to shred_free()
+       2 calls to realloc()
+ -------
+  398752 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  199495 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  199255 calls to shred_free()
+       2 calls to realloc()
+ -------
+  398752 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  199867 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  199627 calls to shred_free()
+       2 calls to realloc()
+ -------
+  399496 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  199867 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  199627 calls to shred_free()
+       2 calls to realloc()
+ -------
+  399496 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  200239 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  199999 calls to shred_free()
+       2 calls to realloc()
+ -------
+  400240 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  200239 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  199999 calls to shred_free()
+       2 calls to realloc()
+ -------
+  400240 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  200611 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  200371 calls to shred_free()
+       2 calls to realloc()
+ -------
+  400984 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  200611 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  200371 calls to shred_free()
+       2 calls to realloc()
+ -------
+  400984 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  200983 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  200743 calls to shred_free()
+       2 calls to realloc()
+ -------
+  401728 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  200983 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  200743 calls to shred_free()
+       2 calls to realloc()
+ -------
+  401728 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  201355 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  201115 calls to shred_free()
+       2 calls to realloc()
+ -------
+  402472 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  201355 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  201115 calls to shred_free()
+       2 calls to realloc()
+ -------
+  402472 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  201727 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  201487 calls to shred_free()
+       2 calls to realloc()
+ -------
+  403216 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  201727 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  201487 calls to shred_free()
+       2 calls to realloc()
+ -------
+  403216 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  202099 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  201859 calls to shred_free()
+       2 calls to realloc()
+ -------
+  403960 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  202099 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  201859 calls to shred_free()
+       2 calls to realloc()
+ -------
+  403960 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  202471 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  202231 calls to shred_free()
+       2 calls to realloc()
+ -------
+  404704 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  202471 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  202231 calls to shred_free()
+       2 calls to realloc()
+ -------
+  404704 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  202843 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  202603 calls to shred_free()
+       2 calls to realloc()
+ -------
+  405448 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  202843 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  202603 calls to shred_free()
+       2 calls to realloc()
+ -------
+  405448 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  203215 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  202975 calls to shred_free()
+       2 calls to realloc()
+ -------
+  406192 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  203215 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  202975 calls to shred_free()
+       2 calls to realloc()
+ -------
+  406192 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  203587 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  203347 calls to shred_free()
+       2 calls to realloc()
+ -------
+  406936 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  203587 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  203347 calls to shred_free()
+       2 calls to realloc()
+ -------
+  406936 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  203959 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  203719 calls to shred_free()
+       2 calls to realloc()
+ -------
+  407680 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  203959 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  203719 calls to shred_free()
+       2 calls to realloc()
+ -------
+  407680 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  204331 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  204091 calls to shred_free()
+       2 calls to realloc()
+ -------
+  408424 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  204331 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  204091 calls to shred_free()
+       2 calls to realloc()
+ -------
+  408424 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  204703 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  204463 calls to shred_free()
+       2 calls to realloc()
+ -------
+  409168 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  204703 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  204463 calls to shred_free()
+       2 calls to realloc()
+ -------
+  409168 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  205075 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  204835 calls to shred_free()
+       2 calls to realloc()
+ -------
+  409912 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  205075 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  204835 calls to shred_free()
+       2 calls to realloc()
+ -------
+  409912 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  205447 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  205207 calls to shred_free()
+       2 calls to realloc()
+ -------
+  410656 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  205447 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  205207 calls to shred_free()
+       2 calls to realloc()
+ -------
+  410656 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  205819 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  205579 calls to shred_free()
+       2 calls to realloc()
+ -------
+  411400 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  205819 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  205579 calls to shred_free()
+       2 calls to realloc()
+ -------
+  411400 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  206191 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  205951 calls to shred_free()
+       2 calls to realloc()
+ -------
+  412144 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  206191 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  205951 calls to shred_free()
+       2 calls to realloc()
+ -------
+  412144 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  206563 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  206323 calls to shred_free()
+       2 calls to realloc()
+ -------
+  412888 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  206563 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  206323 calls to shred_free()
+       2 calls to realloc()
+ -------
+  412888 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  206935 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  206695 calls to shred_free()
+       2 calls to realloc()
+ -------
+  413632 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  206935 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  206695 calls to shred_free()
+       2 calls to realloc()
+ -------
+  413632 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  207307 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  207067 calls to shred_free()
+       2 calls to realloc()
+ -------
+  414376 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  207307 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  207067 calls to shred_free()
+       2 calls to realloc()
+ -------
+  414376 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  207679 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  207439 calls to shred_free()
+       2 calls to realloc()
+ -------
+  415120 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  207679 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  207439 calls to shred_free()
+       2 calls to realloc()
+ -------
+  415120 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  208051 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  207811 calls to shred_free()
+       2 calls to realloc()
+ -------
+  415864 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  208051 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  207811 calls to shred_free()
+       2 calls to realloc()
+ -------
+  415864 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  208407 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  208167 calls to shred_free()
+       2 calls to realloc()
+ -------
+  416576 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  208407 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  208167 calls to shred_free()
+       2 calls to realloc()
+ -------
+  416576 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  208763 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  208523 calls to shred_free()
+       2 calls to realloc()
+ -------
+  417288 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  208763 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  208523 calls to shred_free()
+       2 calls to realloc()
+ -------
+  417288 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  209119 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  208879 calls to shred_free()
+       2 calls to realloc()
+ -------
+  418000 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  209119 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  208879 calls to shred_free()
+       2 calls to realloc()
+ -------
+  418000 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  209475 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  209235 calls to shred_free()
+       2 calls to realloc()
+ -------
+  418712 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  209475 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  209235 calls to shred_free()
+       2 calls to realloc()
+ -------
+  418712 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  209831 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  209591 calls to shred_free()
+       2 calls to realloc()
+ -------
+  419424 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  209831 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  209591 calls to shred_free()
+       2 calls to realloc()
+ -------
+  419424 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  210187 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  209947 calls to shred_free()
+       2 calls to realloc()
+ -------
+  420136 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  210187 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  209947 calls to shred_free()
+       2 calls to realloc()
+ -------
+  420136 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  210543 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  210303 calls to shred_free()
+       2 calls to realloc()
+ -------
+  420848 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  210543 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  210303 calls to shred_free()
+       2 calls to realloc()
+ -------
+  420848 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  210899 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  210659 calls to shred_free()
+       2 calls to realloc()
+ -------
+  421560 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  210899 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  210659 calls to shred_free()
+       2 calls to realloc()
+ -------
+  421560 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  211255 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  211015 calls to shred_free()
+       2 calls to realloc()
+ -------
+  422272 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  211255 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  211015 calls to shred_free()
+       2 calls to realloc()
+ -------
+  422272 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  211611 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  211371 calls to shred_free()
+       2 calls to realloc()
+ -------
+  422984 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  211611 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  211371 calls to shred_free()
+       2 calls to realloc()
+ -------
+  422984 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  211967 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  211727 calls to shred_free()
+       2 calls to realloc()
+ -------
+  423696 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  211967 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  211727 calls to shred_free()
+       2 calls to realloc()
+ -------
+  423696 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  212323 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  212083 calls to shred_free()
+       2 calls to realloc()
+ -------
+  424408 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  212323 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  212083 calls to shred_free()
+       2 calls to realloc()
+ -------
+  424408 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  212679 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  212439 calls to shred_free()
+       2 calls to realloc()
+ -------
+  425120 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  212679 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  212439 calls to shred_free()
+       2 calls to realloc()
+ -------
+  425120 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  213035 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  212795 calls to shred_free()
+       2 calls to realloc()
+ -------
+  425832 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  213035 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  212795 calls to shred_free()
+       2 calls to realloc()
+ -------
+  425832 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  213391 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  213151 calls to shred_free()
+       2 calls to realloc()
+ -------
+  426544 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  213391 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  213151 calls to shred_free()
+       2 calls to realloc()
+ -------
+  426544 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  213747 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  213507 calls to shred_free()
+       2 calls to realloc()
+ -------
+  427256 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  213747 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  213507 calls to shred_free()
+       2 calls to realloc()
+ -------
+  427256 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  214103 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  213863 calls to shred_free()
+       2 calls to realloc()
+ -------
+  427968 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  214103 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  213863 calls to shred_free()
+       2 calls to realloc()
+ -------
+  427968 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  214459 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  214219 calls to shred_free()
+       2 calls to realloc()
+ -------
+  428680 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  214459 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  214219 calls to shred_free()
+       2 calls to realloc()
+ -------
+  428680 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  214815 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  214575 calls to shred_free()
+       2 calls to realloc()
+ -------
+  429392 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  214815 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  214575 calls to shred_free()
+       2 calls to realloc()
+ -------
+  429392 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  215171 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  214931 calls to shred_free()
+       2 calls to realloc()
+ -------
+  430104 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  215171 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  214931 calls to shred_free()
+       2 calls to realloc()
+ -------
+  430104 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  215527 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  215287 calls to shred_free()
+       2 calls to realloc()
+ -------
+  430816 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  215527 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  215287 calls to shred_free()
+       2 calls to realloc()
+ -------
+  430816 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  215883 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  215643 calls to shred_free()
+       2 calls to realloc()
+ -------
+  431528 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  215883 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  215643 calls to shred_free()
+       2 calls to realloc()
+ -------
+  431528 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  216239 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  215999 calls to shred_free()
+       2 calls to realloc()
+ -------
+  432240 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  216239 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  215999 calls to shred_free()
+       2 calls to realloc()
+ -------
+  432240 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  216595 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  216355 calls to shred_free()
+       2 calls to realloc()
+ -------
+  432952 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  216595 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  216355 calls to shred_free()
+       2 calls to realloc()
+ -------
+  432952 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  216951 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  216711 calls to shred_free()
+       2 calls to realloc()
+ -------
+  433664 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  216951 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  216711 calls to shred_free()
+       2 calls to realloc()
+ -------
+  433664 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  217307 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  217067 calls to shred_free()
+       2 calls to realloc()
+ -------
+  434376 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  217307 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  217067 calls to shred_free()
+       2 calls to realloc()
+ -------
+  434376 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  217663 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  217423 calls to shred_free()
+       2 calls to realloc()
+ -------
+  435088 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  217663 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  217423 calls to shred_free()
+       2 calls to realloc()
+ -------
+  435088 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  218019 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  217779 calls to shred_free()
+       2 calls to realloc()
+ -------
+  435800 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  218019 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  217779 calls to shred_free()
+       2 calls to realloc()
+ -------
+  435800 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  218375 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  218135 calls to shred_free()
+       2 calls to realloc()
+ -------
+  436512 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  218375 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  218135 calls to shred_free()
+       2 calls to realloc()
+ -------
+  436512 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  218731 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  218491 calls to shred_free()
+       2 calls to realloc()
+ -------
+  437224 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  218731 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  218491 calls to shred_free()
+       2 calls to realloc()
+ -------
+  437224 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  219087 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  218847 calls to shred_free()
+       2 calls to realloc()
+ -------
+  437936 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  219087 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  218847 calls to shred_free()
+       2 calls to realloc()
+ -------
+  437936 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  219443 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  219203 calls to shred_free()
+       2 calls to realloc()
+ -------
+  438648 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  219443 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  219203 calls to shred_free()
+       2 calls to realloc()
+ -------
+  438648 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  219799 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  219559 calls to shred_free()
+       2 calls to realloc()
+ -------
+  439360 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  219799 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  219559 calls to shred_free()
+       2 calls to realloc()
+ -------
+  439360 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  220155 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  219915 calls to shred_free()
+       2 calls to realloc()
+ -------
+  440072 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  220155 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  219915 calls to shred_free()
+       2 calls to realloc()
+ -------
+  440072 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  220511 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  220271 calls to shred_free()
+       2 calls to realloc()
+ -------
+  440784 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  220511 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  220271 calls to shred_free()
+       2 calls to realloc()
+ -------
+  440784 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  220867 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  220627 calls to shred_free()
+       2 calls to realloc()
+ -------
+  441496 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  220867 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  220627 calls to shred_free()
+       2 calls to realloc()
+ -------
+  441496 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  221223 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  220983 calls to shred_free()
+       2 calls to realloc()
+ -------
+  442208 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  221223 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  220983 calls to shred_free()
+       2 calls to realloc()
+ -------
+  442208 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  221579 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  221339 calls to shred_free()
+       2 calls to realloc()
+ -------
+  442920 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  221579 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  221339 calls to shred_free()
+       2 calls to realloc()
+ -------
+  442920 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  221935 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  221695 calls to shred_free()
+       2 calls to realloc()
+ -------
+  443632 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  221935 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  221695 calls to shred_free()
+       2 calls to realloc()
+ -------
+  443632 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  222291 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  222051 calls to shred_free()
+       2 calls to realloc()
+ -------
+  444344 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  222291 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  222051 calls to shred_free()
+       2 calls to realloc()
+ -------
+  444344 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  222647 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  222407 calls to shred_free()
+       2 calls to realloc()
+ -------
+  445056 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  222647 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  222407 calls to shred_free()
+       2 calls to realloc()
+ -------
+  445056 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  223003 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  222763 calls to shred_free()
+       2 calls to realloc()
+ -------
+  445768 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  223003 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  222763 calls to shred_free()
+       2 calls to realloc()
+ -------
+  445768 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  223359 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  223119 calls to shred_free()
+       2 calls to realloc()
+ -------
+  446480 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  223359 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  223119 calls to shred_free()
+       2 calls to realloc()
+ -------
+  446480 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  223715 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  223475 calls to shred_free()
+       2 calls to realloc()
+ -------
+  447192 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  223715 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  223475 calls to shred_free()
+       2 calls to realloc()
+ -------
+  447192 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  224071 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  223831 calls to shred_free()
+       2 calls to realloc()
+ -------
+  447904 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  224071 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  223831 calls to shred_free()
+       2 calls to realloc()
+ -------
+  447904 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  224427 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  224187 calls to shred_free()
+       2 calls to realloc()
+ -------
+  448616 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  224427 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  224187 calls to shred_free()
+       2 calls to realloc()
+ -------
+  448616 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  224783 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  224543 calls to shred_free()
+       2 calls to realloc()
+ -------
+  449328 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  224783 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  224543 calls to shred_free()
+       2 calls to realloc()
+ -------
+  449328 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  225139 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  224899 calls to shred_free()
+       2 calls to realloc()
+ -------
+  450040 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  225139 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  224899 calls to shred_free()
+       2 calls to realloc()
+ -------
+  450040 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  225495 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  225255 calls to shred_free()
+       2 calls to realloc()
+ -------
+  450752 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  225495 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  225255 calls to shred_free()
+       2 calls to realloc()
+ -------
+  450752 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  225851 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  225611 calls to shred_free()
+       2 calls to realloc()
+ -------
+  451464 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  225851 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  225611 calls to shred_free()
+       2 calls to realloc()
+ -------
+  451464 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  226207 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  225967 calls to shred_free()
+       2 calls to realloc()
+ -------
+  452176 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  226207 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  225967 calls to shred_free()
+       2 calls to realloc()
+ -------
+  452176 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  226563 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  226323 calls to shred_free()
+       2 calls to realloc()
+ -------
+  452888 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  226563 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  226323 calls to shred_free()
+       2 calls to realloc()
+ -------
+  452888 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  226919 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  226679 calls to shred_free()
+       2 calls to realloc()
+ -------
+  453600 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  226919 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  226679 calls to shred_free()
+       2 calls to realloc()
+ -------
+  453600 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  227275 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  227035 calls to shred_free()
+       2 calls to realloc()
+ -------
+  454312 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  227275 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  227035 calls to shred_free()
+       2 calls to realloc()
+ -------
+  454312 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  227631 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  227391 calls to shred_free()
+       2 calls to realloc()
+ -------
+  455024 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  227631 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  227391 calls to shred_free()
+       2 calls to realloc()
+ -------
+  455024 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  227987 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  227747 calls to shred_free()
+       2 calls to realloc()
+ -------
+  455736 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  227987 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  227747 calls to shred_free()
+       2 calls to realloc()
+ -------
+  455736 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  228343 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  228103 calls to shred_free()
+       2 calls to realloc()
+ -------
+  456448 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  228343 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  228103 calls to shred_free()
+       2 calls to realloc()
+ -------
+  456448 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  228699 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  228459 calls to shred_free()
+       2 calls to realloc()
+ -------
+  457160 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  228699 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  228459 calls to shred_free()
+       2 calls to realloc()
+ -------
+  457160 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  229055 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  228815 calls to shred_free()
+       2 calls to realloc()
+ -------
+  457872 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  229055 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  228815 calls to shred_free()
+       2 calls to realloc()
+ -------
+  457872 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  229411 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  229171 calls to shred_free()
+       2 calls to realloc()
+ -------
+  458584 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  229411 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  229171 calls to shred_free()
+       2 calls to realloc()
+ -------
+  458584 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  229767 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  229527 calls to shred_free()
+       2 calls to realloc()
+ -------
+  459296 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  229767 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  229527 calls to shred_free()
+       2 calls to realloc()
+ -------
+  459296 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  230123 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  229883 calls to shred_free()
+       2 calls to realloc()
+ -------
+  460008 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  230123 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  229883 calls to shred_free()
+       2 calls to realloc()
+ -------
+  460008 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  230479 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  230239 calls to shred_free()
+       2 calls to realloc()
+ -------
+  460720 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  230479 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  230239 calls to shred_free()
+       2 calls to realloc()
+ -------
+  460720 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  230835 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  230595 calls to shred_free()
+       2 calls to realloc()
+ -------
+  461432 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  230835 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  230595 calls to shred_free()
+       2 calls to realloc()
+ -------
+  461432 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  231191 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  230951 calls to shred_free()
+       2 calls to realloc()
+ -------
+  462144 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  231191 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  230951 calls to shred_free()
+       2 calls to realloc()
+ -------
+  462144 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  231547 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  231307 calls to shred_free()
+       2 calls to realloc()
+ -------
+  462856 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  231547 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  231307 calls to shred_free()
+       2 calls to realloc()
+ -------
+  462856 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  231903 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  231663 calls to shred_free()
+       2 calls to realloc()
+ -------
+  463568 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  231903 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  231663 calls to shred_free()
+       2 calls to realloc()
+ -------
+  463568 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  232259 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  232019 calls to shred_free()
+       2 calls to realloc()
+ -------
+  464280 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  232259 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  232019 calls to shred_free()
+       2 calls to realloc()
+ -------
+  464280 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  232615 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  232375 calls to shred_free()
+       2 calls to realloc()
+ -------
+  464992 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  232615 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  232375 calls to shred_free()
+       2 calls to realloc()
+ -------
+  464992 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  232971 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  232731 calls to shred_free()
+       2 calls to realloc()
+ -------
+  465704 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  232971 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  232731 calls to shred_free()
+       2 calls to realloc()
+ -------
+  465704 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  233327 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  233087 calls to shred_free()
+       2 calls to realloc()
+ -------
+  466416 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  233327 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  233087 calls to shred_free()
+       2 calls to realloc()
+ -------
+  466416 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  233683 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  233443 calls to shred_free()
+       2 calls to realloc()
+ -------
+  467128 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  233683 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  233443 calls to shred_free()
+       2 calls to realloc()
+ -------
+  467128 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  234039 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  233799 calls to shred_free()
+       2 calls to realloc()
+ -------
+  467840 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  234039 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  233799 calls to shred_free()
+       2 calls to realloc()
+ -------
+  467840 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  234395 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  234155 calls to shred_free()
+       2 calls to realloc()
+ -------
+  468552 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  234395 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  234155 calls to shred_free()
+       2 calls to realloc()
+ -------
+  468552 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  234751 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  234511 calls to shred_free()
+       2 calls to realloc()
+ -------
+  469264 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  234751 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  234511 calls to shred_free()
+       2 calls to realloc()
+ -------
+  469264 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  235107 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  234867 calls to shred_free()
+       2 calls to realloc()
+ -------
+  469976 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  235107 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  234867 calls to shred_free()
+       2 calls to realloc()
+ -------
+  469976 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  235463 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  235223 calls to shred_free()
+       2 calls to realloc()
+ -------
+  470688 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  235463 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  235223 calls to shred_free()
+       2 calls to realloc()
+ -------
+  470688 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  235819 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  235579 calls to shred_free()
+       2 calls to realloc()
+ -------
+  471400 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  235819 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  235579 calls to shred_free()
+       2 calls to realloc()
+ -------
+  471400 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  236175 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  235935 calls to shred_free()
+       2 calls to realloc()
+ -------
+  472112 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  236175 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  235935 calls to shred_free()
+       2 calls to realloc()
+ -------
+  472112 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  236531 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  236291 calls to shred_free()
+       2 calls to realloc()
+ -------
+  472824 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  236531 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  236291 calls to shred_free()
+       2 calls to realloc()
+ -------
+  472824 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  236887 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  236647 calls to shred_free()
+       2 calls to realloc()
+ -------
+  473536 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  236887 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  236647 calls to shred_free()
+       2 calls to realloc()
+ -------
+  473536 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  237243 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  237003 calls to shred_free()
+       2 calls to realloc()
+ -------
+  474248 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  237243 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  237003 calls to shred_free()
+       2 calls to realloc()
+ -------
+  474248 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  237599 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  237359 calls to shred_free()
+       2 calls to realloc()
+ -------
+  474960 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  237599 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  237359 calls to shred_free()
+       2 calls to realloc()
+ -------
+  474960 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  237955 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  237715 calls to shred_free()
+       2 calls to realloc()
+ -------
+  475672 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  237955 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  237715 calls to shred_free()
+       2 calls to realloc()
+ -------
+  475672 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  238311 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  238071 calls to shred_free()
+       2 calls to realloc()
+ -------
+  476384 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  238311 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  238071 calls to shred_free()
+       2 calls to realloc()
+ -------
+  476384 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  238667 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  238427 calls to shred_free()
+       2 calls to realloc()
+ -------
+  477096 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  238667 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  238427 calls to shred_free()
+       2 calls to realloc()
+ -------
+  477096 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  239023 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  238783 calls to shred_free()
+       2 calls to realloc()
+ -------
+  477808 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  239023 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  238783 calls to shred_free()
+       2 calls to realloc()
+ -------
+  477808 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  239379 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  239139 calls to shred_free()
+       2 calls to realloc()
+ -------
+  478520 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  239379 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  239139 calls to shred_free()
+       2 calls to realloc()
+ -------
+  478520 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  239735 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  239495 calls to shred_free()
+       2 calls to realloc()
+ -------
+  479232 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  239735 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  239495 calls to shred_free()
+       2 calls to realloc()
+ -------
+  479232 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  240091 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  239851 calls to shred_free()
+       2 calls to realloc()
+ -------
+  479944 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  240091 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  239851 calls to shred_free()
+       2 calls to realloc()
+ -------
+  479944 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  240447 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  240207 calls to shred_free()
+       2 calls to realloc()
+ -------
+  480656 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  240447 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  240207 calls to shred_free()
+       2 calls to realloc()
+ -------
+  480656 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  240803 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  240563 calls to shred_free()
+       2 calls to realloc()
+ -------
+  481368 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  240803 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  240563 calls to shred_free()
+       2 calls to realloc()
+ -------
+  481368 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  241159 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  240919 calls to shred_free()
+       2 calls to realloc()
+ -------
+  482080 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  241159 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  240919 calls to shred_free()
+       2 calls to realloc()
+ -------
+  482080 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  241515 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  241275 calls to shred_free()
+       2 calls to realloc()
+ -------
+  482792 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  241515 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  241275 calls to shred_free()
+       2 calls to realloc()
+ -------
+  482792 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  241871 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  241631 calls to shred_free()
+       2 calls to realloc()
+ -------
+  483504 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  241871 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  241631 calls to shred_free()
+       2 calls to realloc()
+ -------
+  483504 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  242227 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  241987 calls to shred_free()
+       2 calls to realloc()
+ -------
+  484216 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  242227 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  241987 calls to shred_free()
+       2 calls to realloc()
+ -------
+  484216 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  242583 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  242343 calls to shred_free()
+       2 calls to realloc()
+ -------
+  484928 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  242583 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  242343 calls to shred_free()
+       2 calls to realloc()
+ -------
+  484928 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  242939 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  242699 calls to shred_free()
+       2 calls to realloc()
+ -------
+  485640 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  242939 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  242699 calls to shred_free()
+       2 calls to realloc()
+ -------
+  485640 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  243295 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  243055 calls to shred_free()
+       2 calls to realloc()
+ -------
+  486352 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  243295 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  243055 calls to shred_free()
+       2 calls to realloc()
+ -------
+  486352 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  243651 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  243411 calls to shred_free()
+       2 calls to realloc()
+ -------
+  487064 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  243651 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  243411 calls to shred_free()
+       2 calls to realloc()
+ -------
+  487064 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  244007 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  243767 calls to shred_free()
+       2 calls to realloc()
+ -------
+  487776 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  244007 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  243767 calls to shred_free()
+       2 calls to realloc()
+ -------
+  487776 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  244363 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  244123 calls to shred_free()
+       2 calls to realloc()
+ -------
+  488488 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  244363 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  244123 calls to shred_free()
+       2 calls to realloc()
+ -------
+  488488 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  244719 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  244479 calls to shred_free()
+       2 calls to realloc()
+ -------
+  489200 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  244719 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  244479 calls to shred_free()
+       2 calls to realloc()
+ -------
+  489200 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  245075 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  244835 calls to shred_free()
+       2 calls to realloc()
+ -------
+  489912 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  245075 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  244835 calls to shred_free()
+       2 calls to realloc()
+ -------
+  489912 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  245431 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  245191 calls to shred_free()
+       2 calls to realloc()
+ -------
+  490624 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  245431 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  245191 calls to shred_free()
+       2 calls to realloc()
+ -------
+  490624 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  245787 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  245547 calls to shred_free()
+       2 calls to realloc()
+ -------
+  491336 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  245787 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  245547 calls to shred_free()
+       2 calls to realloc()
+ -------
+  491336 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  246143 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  245903 calls to shred_free()
+       2 calls to realloc()
+ -------
+  492048 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  246143 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  245903 calls to shred_free()
+       2 calls to realloc()
+ -------
+  492048 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  246499 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  246259 calls to shred_free()
+       2 calls to realloc()
+ -------
+  492760 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  246499 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  246259 calls to shred_free()
+       2 calls to realloc()
+ -------
+  492760 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  246855 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  246615 calls to shred_free()
+       2 calls to realloc()
+ -------
+  493472 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  246855 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  246615 calls to shred_free()
+       2 calls to realloc()
+ -------
+  493472 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  247211 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  246971 calls to shred_free()
+       2 calls to realloc()
+ -------
+  494184 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  247211 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  246971 calls to shred_free()
+       2 calls to realloc()
+ -------
+  494184 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  247567 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  247327 calls to shred_free()
+       2 calls to realloc()
+ -------
+  494896 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  247567 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  247327 calls to shred_free()
+       2 calls to realloc()
+ -------
+  494896 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  247923 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  247683 calls to shred_free()
+       2 calls to realloc()
+ -------
+  495608 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  247923 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  247683 calls to shred_free()
+       2 calls to realloc()
+ -------
+  495608 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  248279 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  248039 calls to shred_free()
+       2 calls to realloc()
+ -------
+  496320 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  248279 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  248039 calls to shred_free()
+       2 calls to realloc()
+ -------
+  496320 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  248635 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  248395 calls to shred_free()
+       2 calls to realloc()
+ -------
+  497032 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  248635 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  248395 calls to shred_free()
+       2 calls to realloc()
+ -------
+  497032 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  248991 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  248751 calls to shred_free()
+       2 calls to realloc()
+ -------
+  497744 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  248991 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  248751 calls to shred_free()
+       2 calls to realloc()
+ -------
+  497744 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  249347 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  249107 calls to shred_free()
+       2 calls to realloc()
+ -------
+  498456 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  249347 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  249107 calls to shred_free()
+       2 calls to realloc()
+ -------
+  498456 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  249703 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  249463 calls to shred_free()
+       2 calls to realloc()
+ -------
+  499168 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  249703 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  249463 calls to shred_free()
+       2 calls to realloc()
+ -------
+  499168 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  250059 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  249819 calls to shred_free()
+       2 calls to realloc()
+ -------
+  499880 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  250059 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  249819 calls to shred_free()
+       2 calls to realloc()
+ -------
+  499880 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  250415 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  250175 calls to shred_free()
+       2 calls to realloc()
+ -------
+  500592 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  250415 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  250175 calls to shred_free()
+       2 calls to realloc()
+ -------
+  500592 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  250771 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  250531 calls to shred_free()
+       2 calls to realloc()
+ -------
+  501304 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  250771 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  250531 calls to shred_free()
+       2 calls to realloc()
+ -------
+  501304 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  251127 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  250887 calls to shred_free()
+       2 calls to realloc()
+ -------
+  502016 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  251127 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  250887 calls to shred_free()
+       2 calls to realloc()
+ -------
+  502016 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  251483 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  251243 calls to shred_free()
+       2 calls to realloc()
+ -------
+  502728 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  251483 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  251243 calls to shred_free()
+       2 calls to realloc()
+ -------
+  502728 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  251839 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  251599 calls to shred_free()
+       2 calls to realloc()
+ -------
+  503440 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  251839 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  251599 calls to shred_free()
+       2 calls to realloc()
+ -------
+  503440 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  252195 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  251955 calls to shred_free()
+       2 calls to realloc()
+ -------
+  504152 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  252195 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  251955 calls to shred_free()
+       2 calls to realloc()
+ -------
+  504152 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  252551 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  252311 calls to shred_free()
+       2 calls to realloc()
+ -------
+  504864 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  252551 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  252311 calls to shred_free()
+       2 calls to realloc()
+ -------
+  504864 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  252907 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  252667 calls to shred_free()
+       2 calls to realloc()
+ -------
+  505576 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  252907 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  252667 calls to shred_free()
+       2 calls to realloc()
+ -------
+  505576 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  253263 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  253023 calls to shred_free()
+       2 calls to realloc()
+ -------
+  506288 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  253263 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  253023 calls to shred_free()
+       2 calls to realloc()
+ -------
+  506288 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  253619 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  253379 calls to shred_free()
+       2 calls to realloc()
+ -------
+  507000 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  253619 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  253379 calls to shred_free()
+       2 calls to realloc()
+ -------
+  507000 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  253975 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  253735 calls to shred_free()
+       2 calls to realloc()
+ -------
+  507712 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  253975 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  253735 calls to shred_free()
+       2 calls to realloc()
+ -------
+  507712 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  254331 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  254091 calls to shred_free()
+       2 calls to realloc()
+ -------
+  508424 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  254331 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  254091 calls to shred_free()
+       2 calls to realloc()
+ -------
+  508424 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  254687 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  254447 calls to shred_free()
+       2 calls to realloc()
+ -------
+  509136 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  254687 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  254447 calls to shred_free()
+       2 calls to realloc()
+ -------
+  509136 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  255043 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  254803 calls to shred_free()
+       2 calls to realloc()
+ -------
+  509848 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  255043 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  254803 calls to shred_free()
+       2 calls to realloc()
+ -------
+  509848 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  255399 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  255159 calls to shred_free()
+       2 calls to realloc()
+ -------
+  510560 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  255399 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  255159 calls to shred_free()
+       2 calls to realloc()
+ -------
+  510560 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  255755 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  255515 calls to shred_free()
+       2 calls to realloc()
+ -------
+  511272 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  255755 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  255515 calls to shred_free()
+       2 calls to realloc()
+ -------
+  511272 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  256111 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  255871 calls to shred_free()
+       2 calls to realloc()
+ -------
+  511984 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  256111 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  255871 calls to shred_free()
+       2 calls to realloc()
+ -------
+  511984 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  256467 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  256227 calls to shred_free()
+       2 calls to realloc()
+ -------
+  512696 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  256467 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  256227 calls to shred_free()
+       2 calls to realloc()
+ -------
+  512696 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  256823 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  256583 calls to shred_free()
+       2 calls to realloc()
+ -------
+  513408 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  256823 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  256583 calls to shred_free()
+       2 calls to realloc()
+ -------
+  513408 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  257179 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  256939 calls to shred_free()
+       2 calls to realloc()
+ -------
+  514120 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  257179 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  256939 calls to shred_free()
+       2 calls to realloc()
+ -------
+  514120 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  257535 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  257295 calls to shred_free()
+       2 calls to realloc()
+ -------
+  514832 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  257535 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  257295 calls to shred_free()
+       2 calls to realloc()
+ -------
+  514832 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  257891 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  257651 calls to shred_free()
+       2 calls to realloc()
+ -------
+  515544 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  257891 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  257651 calls to shred_free()
+       2 calls to realloc()
+ -------
+  515544 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  258247 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  258007 calls to shred_free()
+       2 calls to realloc()
+ -------
+  516256 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  258247 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  258007 calls to shred_free()
+       2 calls to realloc()
+ -------
+  516256 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  258603 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  258363 calls to shred_free()
+       2 calls to realloc()
+ -------
+  516968 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  258603 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  258363 calls to shred_free()
+       2 calls to realloc()
+ -------
+  516968 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  258959 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  258719 calls to shred_free()
+       2 calls to realloc()
+ -------
+  517680 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  258959 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  258719 calls to shred_free()
+       2 calls to realloc()
+ -------
+  517680 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  259315 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  259075 calls to shred_free()
+       2 calls to realloc()
+ -------
+  518392 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  259315 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  259075 calls to shred_free()
+       2 calls to realloc()
+ -------
+  518392 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  259671 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  259431 calls to shred_free()
+       2 calls to realloc()
+ -------
+  519104 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  259671 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  259431 calls to shred_free()
+       2 calls to realloc()
+ -------
+  519104 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  260027 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  259787 calls to shred_free()
+       2 calls to realloc()
+ -------
+  519816 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  260027 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  259787 calls to shred_free()
+       2 calls to realloc()
+ -------
+  519816 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  260383 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  260143 calls to shred_free()
+       2 calls to realloc()
+ -------
+  520528 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  260383 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  260143 calls to shred_free()
+       2 calls to realloc()
+ -------
+  520528 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  260739 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  260499 calls to shred_free()
+       2 calls to realloc()
+ -------
+  521240 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  260739 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  260499 calls to shred_free()
+       2 calls to realloc()
+ -------
+  521240 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  261095 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  260855 calls to shred_free()
+       2 calls to realloc()
+ -------
+  521952 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  261095 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  260855 calls to shred_free()
+       2 calls to realloc()
+ -------
+  521952 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  261451 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  261211 calls to shred_free()
+       2 calls to realloc()
+ -------
+  522664 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  261451 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  261211 calls to shred_free()
+       2 calls to realloc()
+ -------
+  522664 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  261807 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  261567 calls to shred_free()
+       2 calls to realloc()
+ -------
+  523376 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  261807 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  261567 calls to shred_free()
+       2 calls to realloc()
+ -------
+  523376 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  262163 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  261923 calls to shred_free()
+       2 calls to realloc()
+ -------
+  524088 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  262163 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  261923 calls to shred_free()
+       2 calls to realloc()
+ -------
+  524088 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  262519 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  262279 calls to shred_free()
+       2 calls to realloc()
+ -------
+  524800 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  262519 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  262279 calls to shred_free()
+       2 calls to realloc()
+ -------
+  524800 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  262875 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  262635 calls to shred_free()
+       2 calls to realloc()
+ -------
+  525512 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  262875 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  262635 calls to shred_free()
+       2 calls to realloc()
+ -------
+  525512 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  263231 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  262991 calls to shred_free()
+       2 calls to realloc()
+ -------
+  526224 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  263231 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  262991 calls to shred_free()
+       2 calls to realloc()
+ -------
+  526224 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  263587 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  263347 calls to shred_free()
+       2 calls to realloc()
+ -------
+  526936 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  263587 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  263347 calls to shred_free()
+       2 calls to realloc()
+ -------
+  526936 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  263943 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  263703 calls to shred_free()
+       2 calls to realloc()
+ -------
+  527648 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  263943 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  263703 calls to shred_free()
+       2 calls to realloc()
+ -------
+  527648 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  264299 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  264059 calls to shred_free()
+       2 calls to realloc()
+ -------
+  528360 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  264299 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  264059 calls to shred_free()
+       2 calls to realloc()
+ -------
+  528360 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  264655 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  264415 calls to shred_free()
+       2 calls to realloc()
+ -------
+  529072 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  264655 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  264415 calls to shred_free()
+       2 calls to realloc()
+ -------
+  529072 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  265011 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  264771 calls to shred_free()
+       2 calls to realloc()
+ -------
+  529784 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  265011 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  264771 calls to shred_free()
+       2 calls to realloc()
+ -------
+  529784 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  265367 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  265127 calls to shred_free()
+       2 calls to realloc()
+ -------
+  530496 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  265367 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  265127 calls to shred_free()
+       2 calls to realloc()
+ -------
+  530496 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  265723 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  265483 calls to shred_free()
+       2 calls to realloc()
+ -------
+  531208 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  265723 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  265483 calls to shred_free()
+       2 calls to realloc()
+ -------
+  531208 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  266079 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  265839 calls to shred_free()
+       2 calls to realloc()
+ -------
+  531920 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  266079 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  265839 calls to shred_free()
+       2 calls to realloc()
+ -------
+  531920 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  266435 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  266195 calls to shred_free()
+       2 calls to realloc()
+ -------
+  532632 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  266435 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  266195 calls to shred_free()
+       2 calls to realloc()
+ -------
+  532632 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  266791 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  266551 calls to shred_free()
+       2 calls to realloc()
+ -------
+  533344 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  266791 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  266551 calls to shred_free()
+       2 calls to realloc()
+ -------
+  533344 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  267147 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  266907 calls to shred_free()
+       2 calls to realloc()
+ -------
+  534056 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  267147 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  266907 calls to shred_free()
+       2 calls to realloc()
+ -------
+  534056 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  267503 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  267263 calls to shred_free()
+       2 calls to realloc()
+ -------
+  534768 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  267503 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  267263 calls to shred_free()
+       2 calls to realloc()
+ -------
+  534768 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  267859 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  267619 calls to shred_free()
+       2 calls to realloc()
+ -------
+  535480 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  267859 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  267619 calls to shred_free()
+       2 calls to realloc()
+ -------
+  535480 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  268215 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  267975 calls to shred_free()
+       2 calls to realloc()
+ -------
+  536192 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  268215 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  267975 calls to shred_free()
+       2 calls to realloc()
+ -------
+  536192 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  268571 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  268331 calls to shred_free()
+       2 calls to realloc()
+ -------
+  536904 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  268571 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  268331 calls to shred_free()
+       2 calls to realloc()
+ -------
+  536904 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  268927 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  268687 calls to shred_free()
+       2 calls to realloc()
+ -------
+  537616 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  268927 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  268687 calls to shred_free()
+       2 calls to realloc()
+ -------
+  537616 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  269283 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  269043 calls to shred_free()
+       2 calls to realloc()
+ -------
+  538328 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  269283 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  269043 calls to shred_free()
+       2 calls to realloc()
+ -------
+  538328 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  269639 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  269399 calls to shred_free()
+       2 calls to realloc()
+ -------
+  539040 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  269639 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  269399 calls to shred_free()
+       2 calls to realloc()
+ -------
+  539040 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  269995 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  269755 calls to shred_free()
+       2 calls to realloc()
+ -------
+  539752 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  269995 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  269755 calls to shred_free()
+       2 calls to realloc()
+ -------
+  539752 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  270351 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  270111 calls to shred_free()
+       2 calls to realloc()
+ -------
+  540464 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  270351 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  270111 calls to shred_free()
+       2 calls to realloc()
+ -------
+  540464 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  270707 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  270467 calls to shred_free()
+       2 calls to realloc()
+ -------
+  541176 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  270707 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  270467 calls to shred_free()
+       2 calls to realloc()
+ -------
+  541176 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  271063 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  270823 calls to shred_free()
+       2 calls to realloc()
+ -------
+  541888 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  271063 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  270823 calls to shred_free()
+       2 calls to realloc()
+ -------
+  541888 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  271419 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  271179 calls to shred_free()
+       2 calls to realloc()
+ -------
+  542600 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  271419 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  271179 calls to shred_free()
+       2 calls to realloc()
+ -------
+  542600 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  271775 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  271535 calls to shred_free()
+       2 calls to realloc()
+ -------
+  543312 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  271775 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  271535 calls to shred_free()
+       2 calls to realloc()
+ -------
+  543312 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  272131 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  271891 calls to shred_free()
+       2 calls to realloc()
+ -------
+  544024 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  272131 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  271891 calls to shred_free()
+       2 calls to realloc()
+ -------
+  544024 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  272487 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  272247 calls to shred_free()
+       2 calls to realloc()
+ -------
+  544736 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  272487 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  272247 calls to shred_free()
+       2 calls to realloc()
+ -------
+  544736 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  272843 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  272603 calls to shred_free()
+       2 calls to realloc()
+ -------
+  545448 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  272843 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  272603 calls to shred_free()
+       2 calls to realloc()
+ -------
+  545448 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  273199 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  272959 calls to shred_free()
+       2 calls to realloc()
+ -------
+  546160 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  273199 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  272959 calls to shred_free()
+       2 calls to realloc()
+ -------
+  546160 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  273555 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  273315 calls to shred_free()
+       2 calls to realloc()
+ -------
+  546872 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  273555 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  273315 calls to shred_free()
+       2 calls to realloc()
+ -------
+  546872 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  273911 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  273671 calls to shred_free()
+       2 calls to realloc()
+ -------
+  547584 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  273911 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  273671 calls to shred_free()
+       2 calls to realloc()
+ -------
+  547584 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  274267 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  274027 calls to shred_free()
+       2 calls to realloc()
+ -------
+  548296 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  274267 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  274027 calls to shred_free()
+       2 calls to realloc()
+ -------
+  548296 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  274623 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  274383 calls to shred_free()
+       2 calls to realloc()
+ -------
+  549008 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  274623 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  274383 calls to shred_free()
+       2 calls to realloc()
+ -------
+  549008 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  274979 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  274739 calls to shred_free()
+       2 calls to realloc()
+ -------
+  549720 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  274979 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  274739 calls to shred_free()
+       2 calls to realloc()
+ -------
+  549720 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  275335 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  275095 calls to shred_free()
+       2 calls to realloc()
+ -------
+  550432 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  275335 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  275095 calls to shred_free()
+       2 calls to realloc()
+ -------
+  550432 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  275691 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  275451 calls to shred_free()
+       2 calls to realloc()
+ -------
+  551144 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  275691 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  275451 calls to shred_free()
+       2 calls to realloc()
+ -------
+  551144 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  276047 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  275807 calls to shred_free()
+       2 calls to realloc()
+ -------
+  551856 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  276047 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  275807 calls to shred_free()
+       2 calls to realloc()
+ -------
+  551856 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  276403 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  276163 calls to shred_free()
+       2 calls to realloc()
+ -------
+  552568 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  276403 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  276163 calls to shred_free()
+       2 calls to realloc()
+ -------
+  552568 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  276759 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  276519 calls to shred_free()
+       2 calls to realloc()
+ -------
+  553280 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  276759 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  276519 calls to shred_free()
+       2 calls to realloc()
+ -------
+  553280 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  277115 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  276875 calls to shred_free()
+       2 calls to realloc()
+ -------
+  553992 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  277115 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  276875 calls to shred_free()
+       2 calls to realloc()
+ -------
+  553992 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  277471 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  277231 calls to shred_free()
+       2 calls to realloc()
+ -------
+  554704 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  277471 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  277231 calls to shred_free()
+       2 calls to realloc()
+ -------
+  554704 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  277827 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  277587 calls to shred_free()
+       2 calls to realloc()
+ -------
+  555416 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  277827 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  277587 calls to shred_free()
+       2 calls to realloc()
+ -------
+  555416 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  278183 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  277943 calls to shred_free()
+       2 calls to realloc()
+ -------
+  556128 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  278183 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  277943 calls to shred_free()
+       2 calls to realloc()
+ -------
+  556128 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  278539 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  278299 calls to shred_free()
+       2 calls to realloc()
+ -------
+  556840 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  278539 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  278299 calls to shred_free()
+       2 calls to realloc()
+ -------
+  556840 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  278895 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  278655 calls to shred_free()
+       2 calls to realloc()
+ -------
+  557552 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  278895 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  278655 calls to shred_free()
+       2 calls to realloc()
+ -------
+  557552 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  279251 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  279011 calls to shred_free()
+       2 calls to realloc()
+ -------
+  558264 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  279251 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  279011 calls to shred_free()
+       2 calls to realloc()
+ -------
+  558264 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  279607 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  279367 calls to shred_free()
+       2 calls to realloc()
+ -------
+  558976 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  279607 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  279367 calls to shred_free()
+       2 calls to realloc()
+ -------
+  558976 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  279963 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  279723 calls to shred_free()
+       2 calls to realloc()
+ -------
+  559688 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  279963 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  279723 calls to shred_free()
+       2 calls to realloc()
+ -------
+  559688 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  280319 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  280079 calls to shred_free()
+       2 calls to realloc()
+ -------
+  560400 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  280319 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  280079 calls to shred_free()
+       2 calls to realloc()
+ -------
+  560400 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  280675 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  280435 calls to shred_free()
+       2 calls to realloc()
+ -------
+  561112 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  280675 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  280435 calls to shred_free()
+       2 calls to realloc()
+ -------
+  561112 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  281031 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  280791 calls to shred_free()
+       2 calls to realloc()
+ -------
+  561824 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  281031 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  280791 calls to shred_free()
+       2 calls to realloc()
+ -------
+  561824 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  281387 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  281147 calls to shred_free()
+       2 calls to realloc()
+ -------
+  562536 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  281387 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  281147 calls to shred_free()
+       2 calls to realloc()
+ -------
+  562536 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  281743 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  281503 calls to shred_free()
+       2 calls to realloc()
+ -------
+  563248 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  281743 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  281503 calls to shred_free()
+       2 calls to realloc()
+ -------
+  563248 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  282099 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  281859 calls to shred_free()
+       2 calls to realloc()
+ -------
+  563960 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  282099 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  281859 calls to shred_free()
+       2 calls to realloc()
+ -------
+  563960 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  282455 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  282215 calls to shred_free()
+       2 calls to realloc()
+ -------
+  564672 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  282455 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  282215 calls to shred_free()
+       2 calls to realloc()
+ -------
+  564672 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  282811 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  282571 calls to shred_free()
+       2 calls to realloc()
+ -------
+  565384 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  282811 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  282571 calls to shred_free()
+       2 calls to realloc()
+ -------
+  565384 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  283167 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  282927 calls to shred_free()
+       2 calls to realloc()
+ -------
+  566096 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  283167 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  282927 calls to shred_free()
+       2 calls to realloc()
+ -------
+  566096 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  283523 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  283283 calls to shred_free()
+       2 calls to realloc()
+ -------
+  566808 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  283523 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  283283 calls to shred_free()
+       2 calls to realloc()
+ -------
+  566808 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  283879 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  283639 calls to shred_free()
+       2 calls to realloc()
+ -------
+  567520 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  283879 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  283639 calls to shred_free()
+       2 calls to realloc()
+ -------
+  567520 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  284235 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  283995 calls to shred_free()
+       2 calls to realloc()
+ -------
+  568232 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  284235 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  283995 calls to shred_free()
+       2 calls to realloc()
+ -------
+  568232 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  284591 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  284351 calls to shred_free()
+       2 calls to realloc()
+ -------
+  568944 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  284591 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  284351 calls to shred_free()
+       2 calls to realloc()
+ -------
+  568944 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  284947 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  284707 calls to shred_free()
+       2 calls to realloc()
+ -------
+  569656 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  284947 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  284707 calls to shred_free()
+       2 calls to realloc()
+ -------
+  569656 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  285303 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  285063 calls to shred_free()
+       2 calls to realloc()
+ -------
+  570368 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  285303 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  285063 calls to shred_free()
+       2 calls to realloc()
+ -------
+  570368 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  285659 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  285419 calls to shred_free()
+       2 calls to realloc()
+ -------
+  571080 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  285659 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  285419 calls to shred_free()
+       2 calls to realloc()
+ -------
+  571080 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  286015 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  285775 calls to shred_free()
+       2 calls to realloc()
+ -------
+  571792 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  286015 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  285775 calls to shred_free()
+       2 calls to realloc()
+ -------
+  571792 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  286371 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  286131 calls to shred_free()
+       2 calls to realloc()
+ -------
+  572504 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  286371 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  286131 calls to shred_free()
+       2 calls to realloc()
+ -------
+  572504 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  286727 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  286487 calls to shred_free()
+       2 calls to realloc()
+ -------
+  573216 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  286727 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  286487 calls to shred_free()
+       2 calls to realloc()
+ -------
+  573216 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  287083 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  286843 calls to shred_free()
+       2 calls to realloc()
+ -------
+  573928 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  287083 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  286843 calls to shred_free()
+       2 calls to realloc()
+ -------
+  573928 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  287439 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  287199 calls to shred_free()
+       2 calls to realloc()
+ -------
+  574640 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  287439 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  287199 calls to shred_free()
+       2 calls to realloc()
+ -------
+  574640 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  287795 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  287555 calls to shred_free()
+       2 calls to realloc()
+ -------
+  575352 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  287795 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  287555 calls to shred_free()
+       2 calls to realloc()
+ -------
+  575352 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  288151 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  287911 calls to shred_free()
+       2 calls to realloc()
+ -------
+  576064 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  288151 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  287911 calls to shred_free()
+       2 calls to realloc()
+ -------
+  576064 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  288507 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  288267 calls to shred_free()
+       2 calls to realloc()
+ -------
+  576776 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  288507 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  288267 calls to shred_free()
+       2 calls to realloc()
+ -------
+  576776 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  288863 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  288623 calls to shred_free()
+       2 calls to realloc()
+ -------
+  577488 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  288863 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  288623 calls to shred_free()
+       2 calls to realloc()
+ -------
+  577488 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  289219 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  288979 calls to shred_free()
+       2 calls to realloc()
+ -------
+  578200 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  289219 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  288979 calls to shred_free()
+       2 calls to realloc()
+ -------
+  578200 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  289575 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  289335 calls to shred_free()
+       2 calls to realloc()
+ -------
+  578912 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  289575 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  289335 calls to shred_free()
+       2 calls to realloc()
+ -------
+  578912 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  289931 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  289691 calls to shred_free()
+       2 calls to realloc()
+ -------
+  579624 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  289931 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  289691 calls to shred_free()
+       2 calls to realloc()
+ -------
+  579624 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  290287 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  290047 calls to shred_free()
+       2 calls to realloc()
+ -------
+  580336 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  290287 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  290047 calls to shred_free()
+       2 calls to realloc()
+ -------
+  580336 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  290643 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  290403 calls to shred_free()
+       2 calls to realloc()
+ -------
+  581048 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  290643 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  290403 calls to shred_free()
+       2 calls to realloc()
+ -------
+  581048 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  290999 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  290759 calls to shred_free()
+       2 calls to realloc()
+ -------
+  581760 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  290999 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  290759 calls to shred_free()
+       2 calls to realloc()
+ -------
+  581760 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  291355 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  291115 calls to shred_free()
+       2 calls to realloc()
+ -------
+  582472 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  291355 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  291115 calls to shred_free()
+       2 calls to realloc()
+ -------
+  582472 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  291711 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  291471 calls to shred_free()
+       2 calls to realloc()
+ -------
+  583184 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  291711 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  291471 calls to shred_free()
+       2 calls to realloc()
+ -------
+  583184 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  292067 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  291827 calls to shred_free()
+       2 calls to realloc()
+ -------
+  583896 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  292067 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  291827 calls to shred_free()
+       2 calls to realloc()
+ -------
+  583896 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  292423 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  292183 calls to shred_free()
+       2 calls to realloc()
+ -------
+  584608 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  292423 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  292183 calls to shred_free()
+       2 calls to realloc()
+ -------
+  584608 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  292779 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  292539 calls to shred_free()
+       2 calls to realloc()
+ -------
+  585320 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  292779 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  292539 calls to shred_free()
+       2 calls to realloc()
+ -------
+  585320 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  293135 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  292895 calls to shred_free()
+       2 calls to realloc()
+ -------
+  586032 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  293135 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  292895 calls to shred_free()
+       2 calls to realloc()
+ -------
+  586032 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  293491 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  293251 calls to shred_free()
+       2 calls to realloc()
+ -------
+  586744 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  293491 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  293251 calls to shred_free()
+       2 calls to realloc()
+ -------
+  586744 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  293847 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  293607 calls to shred_free()
+       2 calls to realloc()
+ -------
+  587456 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  293847 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  293607 calls to shred_free()
+       2 calls to realloc()
+ -------
+  587456 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  294203 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  293963 calls to shred_free()
+       2 calls to realloc()
+ -------
+  588168 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  294203 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  293963 calls to shred_free()
+       2 calls to realloc()
+ -------
+  588168 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  294559 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  294319 calls to shred_free()
+       2 calls to realloc()
+ -------
+  588880 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  294559 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  294319 calls to shred_free()
+       2 calls to realloc()
+ -------
+  588880 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  294915 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  294675 calls to shred_free()
+       2 calls to realloc()
+ -------
+  589592 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  294915 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  294675 calls to shred_free()
+       2 calls to realloc()
+ -------
+  589592 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  295271 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  295031 calls to shred_free()
+       2 calls to realloc()
+ -------
+  590304 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  295271 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  295031 calls to shred_free()
+       2 calls to realloc()
+ -------
+  590304 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  295627 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  295387 calls to shred_free()
+       2 calls to realloc()
+ -------
+  591016 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  295627 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  295387 calls to shred_free()
+       2 calls to realloc()
+ -------
+  591016 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  295983 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  295743 calls to shred_free()
+       2 calls to realloc()
+ -------
+  591728 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  295983 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  295743 calls to shred_free()
+       2 calls to realloc()
+ -------
+  591728 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  296339 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  296099 calls to shred_free()
+       2 calls to realloc()
+ -------
+  592440 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  296339 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  296099 calls to shred_free()
+       2 calls to realloc()
+ -------
+  592440 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  296695 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  296455 calls to shred_free()
+       2 calls to realloc()
+ -------
+  593152 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  296695 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  296455 calls to shred_free()
+       2 calls to realloc()
+ -------
+  593152 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  297051 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  296811 calls to shred_free()
+       2 calls to realloc()
+ -------
+  593864 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  297051 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  296811 calls to shred_free()
+       2 calls to realloc()
+ -------
+  593864 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  297407 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  297167 calls to shred_free()
+       2 calls to realloc()
+ -------
+  594576 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  297407 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  297167 calls to shred_free()
+       2 calls to realloc()
+ -------
+  594576 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  297763 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  297523 calls to shred_free()
+       2 calls to realloc()
+ -------
+  595288 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  297763 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  297523 calls to shred_free()
+       2 calls to realloc()
+ -------
+  595288 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  298119 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  297879 calls to shred_free()
+       2 calls to realloc()
+ -------
+  596000 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  298119 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  297879 calls to shred_free()
+       2 calls to realloc()
+ -------
+  596000 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  298475 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  298235 calls to shred_free()
+       2 calls to realloc()
+ -------
+  596712 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  298475 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  298235 calls to shred_free()
+       2 calls to realloc()
+ -------
+  596712 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  298831 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  298591 calls to shred_free()
+       2 calls to realloc()
+ -------
+  597424 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  298831 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  298591 calls to shred_free()
+       2 calls to realloc()
+ -------
+  597424 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  299187 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  298947 calls to shred_free()
+       2 calls to realloc()
+ -------
+  598136 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  299187 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  298947 calls to shred_free()
+       2 calls to realloc()
+ -------
+  598136 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  299543 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  299303 calls to shred_free()
+       2 calls to realloc()
+ -------
+  598848 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  299543 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  299303 calls to shred_free()
+       2 calls to realloc()
+ -------
+  598848 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  299899 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  299659 calls to shred_free()
+       2 calls to realloc()
+ -------
+  599560 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  299899 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  299659 calls to shred_free()
+       2 calls to realloc()
+ -------
+  599560 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  300255 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  300015 calls to shred_free()
+       2 calls to realloc()
+ -------
+  600272 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  300255 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  300015 calls to shred_free()
+       2 calls to realloc()
+ -------
+  600272 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  300611 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  300371 calls to shred_free()
+       2 calls to realloc()
+ -------
+  600984 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  300611 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  300371 calls to shred_free()
+       2 calls to realloc()
+ -------
+  600984 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  300967 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  300727 calls to shred_free()
+       2 calls to realloc()
+ -------
+  601696 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  300967 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  300727 calls to shred_free()
+       2 calls to realloc()
+ -------
+  601696 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  301323 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  301083 calls to shred_free()
+       2 calls to realloc()
+ -------
+  602408 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  301323 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  301083 calls to shred_free()
+       2 calls to realloc()
+ -------
+  602408 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  301679 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  301439 calls to shred_free()
+       2 calls to realloc()
+ -------
+  603120 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  301679 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  301439 calls to shred_free()
+       2 calls to realloc()
+ -------
+  603120 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  302035 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  301795 calls to shred_free()
+       2 calls to realloc()
+ -------
+  603832 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  302035 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  301795 calls to shred_free()
+       2 calls to realloc()
+ -------
+  603832 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  302391 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  302151 calls to shred_free()
+       2 calls to realloc()
+ -------
+  604544 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  302391 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  302151 calls to shred_free()
+       2 calls to realloc()
+ -------
+  604544 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  302747 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  302507 calls to shred_free()
+       2 calls to realloc()
+ -------
+  605256 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  302747 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  302507 calls to shred_free()
+       2 calls to realloc()
+ -------
+  605256 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  303103 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  302863 calls to shred_free()
+       2 calls to realloc()
+ -------
+  605968 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  303103 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  302863 calls to shred_free()
+       2 calls to realloc()
+ -------
+  605968 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  303459 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  303219 calls to shred_free()
+       2 calls to realloc()
+ -------
+  606680 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  303459 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  303219 calls to shred_free()
+       2 calls to realloc()
+ -------
+  606680 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  303815 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  303575 calls to shred_free()
+       2 calls to realloc()
+ -------
+  607392 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  303815 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  303575 calls to shred_free()
+       2 calls to realloc()
+ -------
+  607392 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  304171 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  303931 calls to shred_free()
+       2 calls to realloc()
+ -------
+  608104 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  304171 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  303931 calls to shred_free()
+       2 calls to realloc()
+ -------
+  608104 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  304527 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  304287 calls to shred_free()
+       2 calls to realloc()
+ -------
+  608816 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  304527 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  304287 calls to shred_free()
+       2 calls to realloc()
+ -------
+  608816 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  304883 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  304643 calls to shred_free()
+       2 calls to realloc()
+ -------
+  609528 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  304883 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  304643 calls to shred_free()
+       2 calls to realloc()
+ -------
+  609528 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  305239 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  304999 calls to shred_free()
+       2 calls to realloc()
+ -------
+  610240 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  305239 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  304999 calls to shred_free()
+       2 calls to realloc()
+ -------
+  610240 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  305595 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  305355 calls to shred_free()
+       2 calls to realloc()
+ -------
+  610952 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  305595 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  305355 calls to shred_free()
+       2 calls to realloc()
+ -------
+  610952 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  305951 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  305711 calls to shred_free()
+       2 calls to realloc()
+ -------
+  611664 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  305951 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  305711 calls to shred_free()
+       2 calls to realloc()
+ -------
+  611664 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  306307 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  306067 calls to shred_free()
+       2 calls to realloc()
+ -------
+  612376 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  306307 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  306067 calls to shred_free()
+       2 calls to realloc()
+ -------
+  612376 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  306663 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  306423 calls to shred_free()
+       2 calls to realloc()
+ -------
+  613088 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  306663 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  306423 calls to shred_free()
+       2 calls to realloc()
+ -------
+  613088 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  307019 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  306779 calls to shred_free()
+       2 calls to realloc()
+ -------
+  613800 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  307019 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  306779 calls to shred_free()
+       2 calls to realloc()
+ -------
+  613800 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  307375 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  307135 calls to shred_free()
+       2 calls to realloc()
+ -------
+  614512 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  307375 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  307135 calls to shred_free()
+       2 calls to realloc()
+ -------
+  614512 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  307731 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  307491 calls to shred_free()
+       2 calls to realloc()
+ -------
+  615224 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  307731 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  307491 calls to shred_free()
+       2 calls to realloc()
+ -------
+  615224 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  308087 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  307847 calls to shred_free()
+       2 calls to realloc()
+ -------
+  615936 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  308087 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  307847 calls to shred_free()
+       2 calls to realloc()
+ -------
+  615936 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  308443 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  308203 calls to shred_free()
+       2 calls to realloc()
+ -------
+  616648 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  308443 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  308203 calls to shred_free()
+       2 calls to realloc()
+ -------
+  616648 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  308799 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  308559 calls to shred_free()
+       2 calls to realloc()
+ -------
+  617360 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  308799 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  308559 calls to shred_free()
+       2 calls to realloc()
+ -------
+  617360 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  309155 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  308915 calls to shred_free()
+       2 calls to realloc()
+ -------
+  618072 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  309155 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  308915 calls to shred_free()
+       2 calls to realloc()
+ -------
+  618072 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  309511 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  309271 calls to shred_free()
+       2 calls to realloc()
+ -------
+  618784 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  309511 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  309271 calls to shred_free()
+       2 calls to realloc()
+ -------
+  618784 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  309867 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  309627 calls to shred_free()
+       2 calls to realloc()
+ -------
+  619496 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  309867 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  309627 calls to shred_free()
+       2 calls to realloc()
+ -------
+  619496 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  310223 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  309983 calls to shred_free()
+       2 calls to realloc()
+ -------
+  620208 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  310223 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  309983 calls to shred_free()
+       2 calls to realloc()
+ -------
+  620208 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  310579 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  310339 calls to shred_free()
+       2 calls to realloc()
+ -------
+  620920 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  310579 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  310339 calls to shred_free()
+       2 calls to realloc()
+ -------
+  620920 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  310935 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  310695 calls to shred_free()
+       2 calls to realloc()
+ -------
+  621632 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  310935 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  310695 calls to shred_free()
+       2 calls to realloc()
+ -------
+  621632 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  311291 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  311051 calls to shred_free()
+       2 calls to realloc()
+ -------
+  622344 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  311291 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  311051 calls to shred_free()
+       2 calls to realloc()
+ -------
+  622344 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  311647 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  311407 calls to shred_free()
+       2 calls to realloc()
+ -------
+  623056 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  311647 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  311407 calls to shred_free()
+       2 calls to realloc()
+ -------
+  623056 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  312003 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  311763 calls to shred_free()
+       2 calls to realloc()
+ -------
+  623768 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  312003 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  311763 calls to shred_free()
+       2 calls to realloc()
+ -------
+  623768 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  312359 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  312119 calls to shred_free()
+       2 calls to realloc()
+ -------
+  624480 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  312359 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  312119 calls to shred_free()
+       2 calls to realloc()
+ -------
+  624480 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  312715 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  312475 calls to shred_free()
+       2 calls to realloc()
+ -------
+  625192 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  312715 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  312475 calls to shred_free()
+       2 calls to realloc()
+ -------
+  625192 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  313071 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  312831 calls to shred_free()
+       2 calls to realloc()
+ -------
+  625904 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  313071 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  312831 calls to shred_free()
+       2 calls to realloc()
+ -------
+  625904 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  313427 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  313187 calls to shred_free()
+       2 calls to realloc()
+ -------
+  626616 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  313427 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  313187 calls to shred_free()
+       2 calls to realloc()
+ -------
+  626616 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  313783 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  313543 calls to shred_free()
+       2 calls to realloc()
+ -------
+  627328 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  313783 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  313543 calls to shred_free()
+       2 calls to realloc()
+ -------
+  627328 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  314139 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  313899 calls to shred_free()
+       2 calls to realloc()
+ -------
+  628040 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  314139 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  313899 calls to shred_free()
+       2 calls to realloc()
+ -------
+  628040 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  314495 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  314255 calls to shred_free()
+       2 calls to realloc()
+ -------
+  628752 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  314495 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  314255 calls to shred_free()
+       2 calls to realloc()
+ -------
+  628752 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  314851 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  314611 calls to shred_free()
+       2 calls to realloc()
+ -------
+  629464 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  314851 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  314611 calls to shred_free()
+       2 calls to realloc()
+ -------
+  629464 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  315207 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  314967 calls to shred_free()
+       2 calls to realloc()
+ -------
+  630176 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  315207 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  314967 calls to shred_free()
+       2 calls to realloc()
+ -------
+  630176 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  315563 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  315323 calls to shred_free()
+       2 calls to realloc()
+ -------
+  630888 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  315563 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  315323 calls to shred_free()
+       2 calls to realloc()
+ -------
+  630888 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  315919 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  315679 calls to shred_free()
+       2 calls to realloc()
+ -------
+  631600 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  315919 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  315679 calls to shred_free()
+       2 calls to realloc()
+ -------
+  631600 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  316275 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  316035 calls to shred_free()
+       2 calls to realloc()
+ -------
+  632312 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  316275 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  316035 calls to shred_free()
+       2 calls to realloc()
+ -------
+  632312 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  316631 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  316391 calls to shred_free()
+       2 calls to realloc()
+ -------
+  633024 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  316631 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  316391 calls to shred_free()
+       2 calls to realloc()
+ -------
+  633024 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  316987 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  316747 calls to shred_free()
+       2 calls to realloc()
+ -------
+  633736 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  316987 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  316747 calls to shred_free()
+       2 calls to realloc()
+ -------
+  633736 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  317343 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  317103 calls to shred_free()
+       2 calls to realloc()
+ -------
+  634448 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  317343 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  317103 calls to shred_free()
+       2 calls to realloc()
+ -------
+  634448 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  317699 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  317459 calls to shred_free()
+       2 calls to realloc()
+ -------
+  635160 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  317699 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  317459 calls to shred_free()
+       2 calls to realloc()
+ -------
+  635160 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  318055 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  317815 calls to shred_free()
+       2 calls to realloc()
+ -------
+  635872 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  318055 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  317815 calls to shred_free()
+       2 calls to realloc()
+ -------
+  635872 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  318411 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  318171 calls to shred_free()
+       2 calls to realloc()
+ -------
+  636584 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  318411 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  318171 calls to shred_free()
+       2 calls to realloc()
+ -------
+  636584 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  318767 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  318527 calls to shred_free()
+       2 calls to realloc()
+ -------
+  637296 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  318767 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  318527 calls to shred_free()
+       2 calls to realloc()
+ -------
+  637296 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  319123 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  318883 calls to shred_free()
+       2 calls to realloc()
+ -------
+  638008 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  319123 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  318883 calls to shred_free()
+       2 calls to realloc()
+ -------
+  638008 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  319479 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  319239 calls to shred_free()
+       2 calls to realloc()
+ -------
+  638720 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  319479 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  319239 calls to shred_free()
+       2 calls to realloc()
+ -------
+  638720 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  319835 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  319595 calls to shred_free()
+       2 calls to realloc()
+ -------
+  639432 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  319835 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  319595 calls to shred_free()
+       2 calls to realloc()
+ -------
+  639432 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  320191 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  319951 calls to shred_free()
+       2 calls to realloc()
+ -------
+  640144 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  320191 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  319951 calls to shred_free()
+       2 calls to realloc()
+ -------
+  640144 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  320547 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  320307 calls to shred_free()
+       2 calls to realloc()
+ -------
+  640856 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  320547 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  320307 calls to shred_free()
+       2 calls to realloc()
+ -------
+  640856 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  320903 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  320663 calls to shred_free()
+       2 calls to realloc()
+ -------
+  641568 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  320903 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  320663 calls to shred_free()
+       2 calls to realloc()
+ -------
+  641568 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  321259 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  321019 calls to shred_free()
+       2 calls to realloc()
+ -------
+  642280 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  321259 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  321019 calls to shred_free()
+       2 calls to realloc()
+ -------
+  642280 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  321615 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  321375 calls to shred_free()
+       2 calls to realloc()
+ -------
+  642992 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  321615 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  321375 calls to shred_free()
+       2 calls to realloc()
+ -------
+  642992 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  321971 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  321731 calls to shred_free()
+       2 calls to realloc()
+ -------
+  643704 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  321971 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  321731 calls to shred_free()
+       2 calls to realloc()
+ -------
+  643704 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  322327 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  322087 calls to shred_free()
+       2 calls to realloc()
+ -------
+  644416 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  322327 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  322087 calls to shred_free()
+       2 calls to realloc()
+ -------
+  644416 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  322683 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  322443 calls to shred_free()
+       2 calls to realloc()
+ -------
+  645128 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  322683 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  322443 calls to shred_free()
+       2 calls to realloc()
+ -------
+  645128 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  323039 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  322799 calls to shred_free()
+       2 calls to realloc()
+ -------
+  645840 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  323039 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  322799 calls to shred_free()
+       2 calls to realloc()
+ -------
+  645840 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  323395 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  323155 calls to shred_free()
+       2 calls to realloc()
+ -------
+  646552 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  323395 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  323155 calls to shred_free()
+       2 calls to realloc()
+ -------
+  646552 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  323751 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  323511 calls to shred_free()
+       2 calls to realloc()
+ -------
+  647264 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  323751 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  323511 calls to shred_free()
+       2 calls to realloc()
+ -------
+  647264 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  324107 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  323867 calls to shred_free()
+       2 calls to realloc()
+ -------
+  647976 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  324107 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  323867 calls to shred_free()
+       2 calls to realloc()
+ -------
+  647976 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  324463 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  324223 calls to shred_free()
+       2 calls to realloc()
+ -------
+  648688 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  324463 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  324223 calls to shred_free()
+       2 calls to realloc()
+ -------
+  648688 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  324819 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  324579 calls to shred_free()
+       2 calls to realloc()
+ -------
+  649400 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  324819 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  324579 calls to shred_free()
+       2 calls to realloc()
+ -------
+  649400 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  325175 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  324935 calls to shred_free()
+       2 calls to realloc()
+ -------
+  650112 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  325175 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  324935 calls to shred_free()
+       2 calls to realloc()
+ -------
+  650112 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  325531 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  325291 calls to shred_free()
+       2 calls to realloc()
+ -------
+  650824 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  325531 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  325291 calls to shred_free()
+       2 calls to realloc()
+ -------
+  650824 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  325887 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  325647 calls to shred_free()
+       2 calls to realloc()
+ -------
+  651536 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  325887 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  325647 calls to shred_free()
+       2 calls to realloc()
+ -------
+  651536 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  326243 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  326003 calls to shred_free()
+       2 calls to realloc()
+ -------
+  652248 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  326243 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  326003 calls to shred_free()
+       2 calls to realloc()
+ -------
+  652248 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  326599 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  326359 calls to shred_free()
+       2 calls to realloc()
+ -------
+  652960 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  326599 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  326359 calls to shred_free()
+       2 calls to realloc()
+ -------
+  652960 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  326955 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  326715 calls to shred_free()
+       2 calls to realloc()
+ -------
+  653672 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  326955 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  326715 calls to shred_free()
+       2 calls to realloc()
+ -------
+  653672 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  327311 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  327071 calls to shred_free()
+       2 calls to realloc()
+ -------
+  654384 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  327311 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  327071 calls to shred_free()
+       2 calls to realloc()
+ -------
+  654384 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  327667 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  327427 calls to shred_free()
+       2 calls to realloc()
+ -------
+  655096 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  327667 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  327427 calls to shred_free()
+       2 calls to realloc()
+ -------
+  655096 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  328023 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  327783 calls to shred_free()
+       2 calls to realloc()
+ -------
+  655808 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  328023 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  327783 calls to shred_free()
+       2 calls to realloc()
+ -------
+  655808 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  328379 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  328139 calls to shred_free()
+       2 calls to realloc()
+ -------
+  656520 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  328379 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  328139 calls to shred_free()
+       2 calls to realloc()
+ -------
+  656520 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  328735 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  328495 calls to shred_free()
+       2 calls to realloc()
+ -------
+  657232 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  328735 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  328495 calls to shred_free()
+       2 calls to realloc()
+ -------
+  657232 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  329091 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  328851 calls to shred_free()
+       2 calls to realloc()
+ -------
+  657944 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  329091 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  328851 calls to shred_free()
+       2 calls to realloc()
+ -------
+  657944 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  329447 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  329207 calls to shred_free()
+       2 calls to realloc()
+ -------
+  658656 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  329447 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  329207 calls to shred_free()
+       2 calls to realloc()
+ -------
+  658656 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  329803 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  329563 calls to shred_free()
+       2 calls to realloc()
+ -------
+  659368 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  329803 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  329563 calls to shred_free()
+       2 calls to realloc()
+ -------
+  659368 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  330159 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  329919 calls to shred_free()
+       2 calls to realloc()
+ -------
+  660080 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  330159 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  329919 calls to shred_free()
+       2 calls to realloc()
+ -------
+  660080 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  330515 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  330275 calls to shred_free()
+       2 calls to realloc()
+ -------
+  660792 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  330515 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  330275 calls to shred_free()
+       2 calls to realloc()
+ -------
+  660792 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  330871 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  330631 calls to shred_free()
+       2 calls to realloc()
+ -------
+  661504 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  330871 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  330631 calls to shred_free()
+       2 calls to realloc()
+ -------
+  661504 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  331227 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  330987 calls to shred_free()
+       2 calls to realloc()
+ -------
+  662216 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  331227 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  330987 calls to shred_free()
+       2 calls to realloc()
+ -------
+  662216 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  331583 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  331343 calls to shred_free()
+       2 calls to realloc()
+ -------
+  662928 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  331583 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  331343 calls to shred_free()
+       2 calls to realloc()
+ -------
+  662928 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  331939 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  331699 calls to shred_free()
+       2 calls to realloc()
+ -------
+  663640 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  331939 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  331699 calls to shred_free()
+       2 calls to realloc()
+ -------
+  663640 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  332295 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  332055 calls to shred_free()
+       2 calls to realloc()
+ -------
+  664352 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  332295 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  332055 calls to shred_free()
+       2 calls to realloc()
+ -------
+  664352 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  332651 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  332411 calls to shred_free()
+       2 calls to realloc()
+ -------
+  665064 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  332651 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  332411 calls to shred_free()
+       2 calls to realloc()
+ -------
+  665064 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  333007 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  332767 calls to shred_free()
+       2 calls to realloc()
+ -------
+  665776 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  333007 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  332767 calls to shred_free()
+       2 calls to realloc()
+ -------
+  665776 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  333363 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  333123 calls to shred_free()
+       2 calls to realloc()
+ -------
+  666488 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  333363 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  333123 calls to shred_free()
+       2 calls to realloc()
+ -------
+  666488 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  333719 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  333479 calls to shred_free()
+       2 calls to realloc()
+ -------
+  667200 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  333719 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  333479 calls to shred_free()
+       2 calls to realloc()
+ -------
+  667200 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  334075 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  333835 calls to shred_free()
+       2 calls to realloc()
+ -------
+  667912 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  334075 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  333835 calls to shred_free()
+       2 calls to realloc()
+ -------
+  667912 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  334431 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  334191 calls to shred_free()
+       2 calls to realloc()
+ -------
+  668624 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  334431 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  334191 calls to shred_free()
+       2 calls to realloc()
+ -------
+  668624 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  334787 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  334547 calls to shred_free()
+       2 calls to realloc()
+ -------
+  669336 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  334787 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  334547 calls to shred_free()
+       2 calls to realloc()
+ -------
+  669336 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  335143 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  334903 calls to shred_free()
+       2 calls to realloc()
+ -------
+  670048 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  335143 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  334903 calls to shred_free()
+       2 calls to realloc()
+ -------
+  670048 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  335499 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  335259 calls to shred_free()
+       2 calls to realloc()
+ -------
+  670760 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  335499 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  335259 calls to shred_free()
+       2 calls to realloc()
+ -------
+  670760 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  335855 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  335615 calls to shred_free()
+       2 calls to realloc()
+ -------
+  671472 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  335855 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  335615 calls to shred_free()
+       2 calls to realloc()
+ -------
+  671472 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  336211 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  335971 calls to shred_free()
+       2 calls to realloc()
+ -------
+  672184 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  336211 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  335971 calls to shred_free()
+       2 calls to realloc()
+ -------
+  672184 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  336567 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  336327 calls to shred_free()
+       2 calls to realloc()
+ -------
+  672896 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  336567 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  336327 calls to shred_free()
+       2 calls to realloc()
+ -------
+  672896 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  336923 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  336683 calls to shred_free()
+       2 calls to realloc()
+ -------
+  673608 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  336923 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  336683 calls to shred_free()
+       2 calls to realloc()
+ -------
+  673608 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  337279 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  337039 calls to shred_free()
+       2 calls to realloc()
+ -------
+  674320 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  337279 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  337039 calls to shred_free()
+       2 calls to realloc()
+ -------
+  674320 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  337635 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  337395 calls to shred_free()
+       2 calls to realloc()
+ -------
+  675032 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  337635 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  337395 calls to shred_free()
+       2 calls to realloc()
+ -------
+  675032 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  337991 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  337751 calls to shred_free()
+       2 calls to realloc()
+ -------
+  675744 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  337991 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  337751 calls to shred_free()
+       2 calls to realloc()
+ -------
+  675744 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 241 members (241 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43370 bytes due to overhead.
+(That's 43,370 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687513 bytes.
+(That's 687,513 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  338347 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  338107 calls to shred_free()
+       2 calls to realloc()
+ -------
+  676456 calls
+shred_malloc stats:
+hash table sz: 823 blocks
+current: 240 members (240 allocated, 0 freed)
+The underlying real allocator is real_is_gmalloc.c
+Safety zones: 53 bytes before, 42 after
+SHRED_REALLOC_ALWAYS_MOVE not defined;
+  calls to shred_realloc() do not move the block unless necessary.
+Currently wasting 43272 bytes due to overhead.
+(That's 43,272 bytes.)
+Overhead wastage high-water mark: 43664 bytes
+(That's 43,664 bytes.)
+Payload area totals 687489 bytes.
+(That's 687,489 bytes.)
+Payload area high-water mark: 688329 bytes
+(That's 688,329 bytes.)
+Calls to the GNU Malloc functions are magically redirected to shred_calloc(),
+shred_malloc(), shred_memalign(), shred_realloc(), and shred_free()
+
+  338347 calls to shred_malloc() and shred_calloc()
+       0 calls to shred_memalign()
+  338107 calls to shred_free()
+       2 calls to realloc()
+ -------
+  676456 calls