pax_global_header00006660000000000000000000000064152156151110014510gustar00rootroot0000000000000052 comment=d9bb4a9caaccae101f4a79f6c0757c4c3bde7216 iptstate-2.3.0/000077500000000000000000000000001521561511100133475ustar00rootroot00000000000000iptstate-2.3.0/.github/000077500000000000000000000000001521561511100147075ustar00rootroot00000000000000iptstate-2.3.0/.github/dependabot.yml000066400000000000000000000001601521561511100175340ustar00rootroot00000000000000version: 2 updates: - package-ecosystem: github-actions directory: / schedule: interval: weekly iptstate-2.3.0/.github/workflows/000077500000000000000000000000001521561511100167445ustar00rootroot00000000000000iptstate-2.3.0/.github/workflows/build.yml000066400000000000000000000012641521561511100205710ustar00rootroot00000000000000name: Build on: push: branches: [ main ] pull_request: branches: [ main ] permissions: contents: read jobs: build: strategy: fail-fast: false runs-on: ubuntu-latest steps: - name: Harden the runner (Audit all outbound calls) uses: step-security/harden-runner@9af89fc71515a100421586dfdb3dc9c984fbf411 # v2.19.4 with: egress-policy: audit - name: Checkout repository uses: actions/checkout@9c091bb21b7c1c1d1991bb908d89e4e9dddfe3e0 # v7.0.0 - name: Install dependencies run: sudo apt install g++ make libnetfilter-conntrack-dev -y - name: Build run: make - name: Run run: ./iptstate --version iptstate-2.3.0/.github/workflows/check-all-checks.yml000066400000000000000000000007141521561511100225520ustar00rootroot00000000000000name: All checks pass on: pull_request: permissions: {} jobs: allchecks: runs-on: ubuntu-latest permissions: checks: read contents: read steps: - name: Harden the runner (Audit all outbound calls) uses: step-security/harden-runner@9af89fc71515a100421586dfdb3dc9c984fbf411 # v2.19.4 with: egress-policy: audit - uses: wechuli/allcheckspassed@204ff63e89eabdc8086f0c50b91f675bcf37c8f6 # v2.4.0 iptstate-2.3.0/.github/workflows/codeql.yml000066400000000000000000000023571521561511100207450ustar00rootroot00000000000000name: "CodeQL" on: push: branches: ["main"] pull_request: branches: ["main"] schedule: - cron: "0 0 * * 1" permissions: contents: read jobs: analyze: name: Analyze runs-on: ubuntu-latest permissions: actions: read contents: read security-events: write strategy: fail-fast: false matrix: language: ["cpp"] steps: - name: Harden the runner (Audit all outbound calls) uses: step-security/harden-runner@9af89fc71515a100421586dfdb3dc9c984fbf411 # v2.19.4 with: egress-policy: audit - name: Checkout repository uses: actions/checkout@9c091bb21b7c1c1d1991bb908d89e4e9dddfe3e0 # v7.0.0 # Initializes the CodeQL tools for scanning. - name: Initialize CodeQL uses: github/codeql-action/init@8aad20d150bbac5944a9f9d289da16a4b0d87c1e # v4.36.2 with: languages: ${{ matrix.language }} - name: Autobuild uses: github/codeql-action/autobuild@8aad20d150bbac5944a9f9d289da16a4b0d87c1e # v4.36.2 - name: Perform CodeQL Analysis uses: github/codeql-action/analyze@8aad20d150bbac5944a9f9d289da16a4b0d87c1e # v4.36.2 with: category: "/language:${{matrix.language}}" iptstate-2.3.0/.github/workflows/dco.yml000066400000000000000000000013611521561511100202350ustar00rootroot00000000000000name: DCO Check on: [pull_request] permissions: {} jobs: dco_check_job: permissions: contents: read pull-requests: read runs-on: ubuntu-latest name: DCO Check steps: - name: Harden the runner (Audit all outbound calls) uses: step-security/harden-runner@9af89fc71515a100421586dfdb3dc9c984fbf411 # v2.19.4 with: egress-policy: audit - name: Get PR Commits uses: actionshub/get-pr-commits@6fc8a0242c2c5853e3e8b86bde9d176682e5c5fb # main id: 'get-pr-commits' with: token: ${{ secrets.GITHUB_TOKEN }} - name: DCO Check uses: actionshub/dco@da8700138fd5b555270e7c3a49890746d0d2f93f # main with: commits: ${{ steps.get-pr-commits.outputs.commits }} iptstate-2.3.0/.github/workflows/dependency-review.yml000066400000000000000000000011141521561511100231010ustar00rootroot00000000000000name: 'Dependency Review' on: [pull_request] permissions: contents: read jobs: dependency-review: runs-on: ubuntu-latest steps: - name: Harden the runner (Audit all outbound calls) uses: step-security/harden-runner@9af89fc71515a100421586dfdb3dc9c984fbf411 # v2.19.4 with: egress-policy: audit - name: 'Checkout Repository' uses: actions/checkout@9c091bb21b7c1c1d1991bb908d89e4e9dddfe3e0 # v7.0.0 - name: 'Dependency Review' uses: actions/dependency-review-action@a1d282b36b6f3519aa1f3fc636f609c47dddb294 # v5.0.0 iptstate-2.3.0/.github/workflows/lint.yml000066400000000000000000000012211521561511100204310ustar00rootroot00000000000000name: Lint on: push: branches: [ main ] pull_request: branches: [ main ] jobs: markdownlint: runs-on: ubuntu-latest steps: - name: Harden the runner (Audit all outbound calls) uses: step-security/harden-runner@9af89fc71515a100421586dfdb3dc9c984fbf411 # v2.19.4 with: egress-policy: audit - name: checkout uses: actions/checkout@9c091bb21b7c1c1d1991bb908d89e4e9dddfe3e0 # v7.0.0 - name: MarkdownLint mdl Action uses: actionshub/markdownlint@v3.1.4 - name: MarkdownLint mdl Action uses: actionshub/markdownlint@6c82ff529253530dfbf75c37570876c52692835f # 3.1.4 iptstate-2.3.0/.mdl_style.rb000066400000000000000000000000311521561511100157400ustar00rootroot00000000000000all exclude_rule 'MD026' iptstate-2.3.0/.mdlrc000066400000000000000000000000261521561511100144470ustar00rootroot00000000000000style '.mdl_style.rb' iptstate-2.3.0/BUGS000066400000000000000000000047611521561511100140420ustar00rootroot00000000000000IPTState Bugs KNOWN BUGS We keep track of bugs in our bugtracker on our Sourceforge page. However, before filing bugs, be aware of bugs in these other pieces of software that may affect your iptstate experience: - libnetfilter_conntrack 0.0.50 has a bug that prevents iptstate from deleting ICMP states. I wrote the following patch which the netfilter folks have already applied to their SVN tree: http://www.phildev.net/linux/patches/libnetfilter_conntrack-0.0.50_icmp_id.patch You can use it if this affects you. - There seems to be a small memory leak somewhere in ncurses. See http://www.phildev.net/iptstate/memleak.html for details. This won't effect most users much, but you want to be weary of leaving iptstate running on very busy firewalls for very long periods of time (a day or more). This bug has been reported to ncurses, see above URL. ABOUT BUGS If you find a bug in IPTState you should file a bug at our bugtracker: https://sourceforge.net/tracker/?group_id=52748&atid=467897 OR mail our -devel list: https://lists.sourceforge.net/lists/listinfo/iptstate-devel If you are unsure if it's a bug or need support, please use the -devel mailing list. Sending a bug to your distro or some public forum is not going to let me know. I can't fix things I don't know about. So make sure I know! ABOUT MY RESPONSE If your bug is serious - i.e. compilation errors, a major a functionality is broken, or a security problem I'll usually give you pretty immediate attention. If it's a very minor bug, or a feature request, I'll respond as I have time. ABOUT PATCHES Patches are welcome but not necessary. I will fix bugs, don't worry. If you would like to contribute code, PLEASE use consistent style to the rest of the code. If you send a patch, it should be accompanied with a good explanation of what it does and why. If it fixes a bug, it should also be accompanied by a bug report in our bug tracker. ABOUT BUG REPORTS Please be sure to include these things in bug reports: - your iptstate version - your distribution and distribution version - your kernel version - your g++ version (if you built it yourself) - your make version (if you built it yourself) - your glibc version (if you built it yourself) - your ncurses version - your libnetfilter_conntrack version - any relevant output and/or errors Once again, distributions don't always forward bug reports upstream, so please send bug reports to me if you want bugs fixed. Thanks! Phil Dibowitz phil AT ipom DOT com iptstate-2.3.0/CHANGELOG.md000066400000000000000000000150551521561511100151660ustar00rootroot00000000000000# IPTState Changelog ## 2.3.0 (2026-06-20) - Makefile: respect LDFLAGS, CPPFLAGS - Makefile: use pkg-config - Add CI to the repo - Cleanup table entries on all exit possibilities - Don't leak entries when using filters - Update CI to prevent supply-chain attacks - Handle window size even when pipes on stdin/stdnout/stderr - Fix compiler warnings ## 2.2.7 (2021-10-16) - Fix compiler warnings ## 2.2.6 (2016-08-14) - Fix `-b` option which didn't work in many cases - When we turn `lookup` mode on, automatically turn `skipdns` mode on - Move to dynamic memory for state entries. Fixes #3 ## 2.2.5 (2012-06-02) - Full support for ICMP6 including code/type display and state deletion - Dynamically size "State" column - If we can't resolve a protocol to a name, print the number instead of "UNKNOWN!" - Don't leave a space for ":" if there's no port ## 2.2.4 (2012-06-01) - Improved IPv6 support - truncate addresses if they don't fit and generally treat them like hostnames at display time - CONTRIB and man page fixes (Chris Taylor ) ## 2.2.3 (2011-04-04) - IPv6 support. Closes #2848930. - Handle filters as in6_addr and uints instead of strings - Fix loopback filtering support - Fix formatting for ICMP states. Closes #2969917. - Total style overhaul: move away from tabs, use 2 spaces, various other style cleanups - Documentation updates ## 2.2.2 (2009-09-19) - Fix includes - Add --version (closes bug 2792918) - Some minor code abstractions - Remove old /proc based code - Dropped "Proto" field minimum width to 3 chars (changing title to "Prt") to make more room for counters - If we can't fit counters and there's nothing we can truncate, show a warning and then disable counters rather than messing up the display - Some style cleanups ## 2.2.1 (2007-03-19) - Fix formatting bug (maxes not being cleared on each round) ## 2.2.0 (2007-03-19) - Added some logic to handle state tables larger than 32767 entries which breaks ncurses if you try to make a pad that large. - Cleanup the time.h includes - Port to new libnetfilter_conntrack library - Add support for byte/packet counters ('C' key) - Add support for deleting states ('x' key) - Move navigation help to top of interactive help so people can learn how to navigate without having to navigate to the bottom of the help - When --lookup is enabled, resolve port names as well as hostnames (reported by Viliam Holub ) - Display the ICMP ID on ICMP states - Fix scrolling bug if totals or filters were enabled - General improvement of all scrolling calculations - Add 'B' as a way to sort by previous column (opposite of 'b') - Add ^d for pagedown and ^u for pageup ## 2.1 (2006-10-05) - Fixed bug where -s was doing what -S should do and -d was doing what -D should do. Thanks to Brian Nelson for catching this. - Add comments on the 3 functions that didn't have them in 2.0 ## 2.0 (2006-10-04) - Moved man page to section 8 - Significantly re-factored code - Fix long-protocol-names-break-formatting bug (reported by Bill Hudacek ) - Move all flag bools into a new flags_t struct - Move format-decisions to end - Move all counters into a new counters_t struct - Make the stable vector dynamic instead of a huge pre-allocation - Move many variables to #defines - Fix bug in "totals" line (numbers didn't always add up) - Add display of skipped entries on "totals" line - Move various char*'s to strings. - Move most snprintf()s to stringstreams. - Rewrite and significantly improve dynamic sizing of columns - Add a new interactive help window - Add srcpt and dstpt filtering - Add long options - Make interactive help scroll-able - Make main window scroll-able - Make having the main window be scrollable configurable and if not scrollable then use stdscr instead of a pad. Make this togglable interactively. - Redo command-line options so they match interactive options - Add ability to change all filters and the refresh rate interactively - Handle window resizes (SIGWINCH) properly - If we can't read ip_conntrack, error and exit rather than fail silently - Cleanup nicely if we get killed (SIGINT or SIGTERM) - Add color-coding of protocols ## 1.4 (2005-04-16) - Added display of filters - Added a "strip" target to the Makefile - Changed ip/port separator to a colon instead of comma - Some string concat and Makefile cleanups from Roland Illig - Added new features to man page - Added filtering for source and destination addresses - Added filtering of DNS states option - Added tagging of truncated hostnames - Brought man page up-to-date - Got rid of deprecated warnings - Removed libgpm req from spec file. ## 1.3 (2003-05-27) - Steve Augart finally proved the 'memory leak' was in ncurses as I'd always suspected but was unable to prove. Thanks Steve! - Increased snprintf boundaries in printline function to ensure newlines don't get cut off (Thanks to Todd Lyons) - Added dynamic sizing of iptstate based on term info. - Updated Makefile to only recompile if needed - Fixed gethostbyaddr() call to compile on more systems - Fixed truncation bug that occasionally truncated one char too few - Added NOTES section to man page, plus other docs on new features - Fixed some man page bugs ## 1.2.1 (2002-07-01) - Fixes for GCC3 - cast 'x' in 'log' so GCC knows which log I mean - add -Wno-deprecated to Makefile - Fix small bug in manpage that made -R not show up - Fix crash if protocol is not found in /etc/protocols - Update 'uninstall' in Makefile ## 1.2.0 (2002-04-20) - Various doc updates - Lots of code cleanups - Added documentation for interactive-mode options - Added interactive-mode toggles for -f -t -l - Added option to display totals - Added filtering of loopback - Added sorting by hostname - Added DNS hostname lookups - Improved SrcIP and DstIP sorting - Added sorting by port ## 1.1.0 (2002-03-30) - Will now read in all connections instead of just 50; for single-line use, it will display them all as well. - Added command line flag for reverse sorting - Cleaned up reading of options - Fixed sorting of TTL / cleaned up sorting code - Fixed uninstall in Makefile ## 1.0.1 (2002-02-27) - Added spec file so people can build RPMs if they like - Fix 'timeval' compile error for certain platforms - Take out src port and dst port for non tcp,udp cases - Give 'rate' an initial value - Fixed Big Endian Problem with command line arguments - Fixed Makefile (put LIBS at end) - Change "proto" field to look up by protocol number field of ip_conntrack instead of take it from the name field, supporting pretty much any protocol ## 1.0 (2002-02-23) - Original release iptstate-2.3.0/CONTRIB000066400000000000000000000061061521561511100143750ustar00rootroot00000000000000IPTSTATE CONTRIBUTIONS IPTState is written and maintained by Phil Dibowitz I originally wrote the software not planning on releasing it - I wanted a feature similar to IP Filter's StateTop when I was using Linux. I decided to release it. It became much bigger than I expected in just a month. IPTState wouldn't be where it is today without many other people. This is an attempt to credit and thank them. IDEA Darren Reed wrote IP Filter. Frank Volf wrote the Statetop code for IP Filter. PACKAGERS I'm very grateful to those who package my software. I've tried to list maintainers here, but if you're not here, please, let me know and I'll add you. If you package my software _please let me know_, and even more importantly, _please_ pass on bugs to me! Mandriva: Garrick Staples Debian: Chris Taylor (was: Brian Nelson) Gentoo: (was: Eldad Zack) ALT Linux: Victor Forsyuk floppyfw: Cristian Ionescu-Idbohrn pkgsrc: Roland Illig Devil Linux: (was: Bruce Smith) Fedora/RedHat: Thomas Woerner OpenEmbedded: Jamie Lenehen ArchLinux (community repo): Andrea Zucchelli ipcop: Franck Bourdonnec Slackware (slackers.it repo): Corrado Franco OTHER Some people who helped me get this project started were Jullian Gomez, my fellow USCLUG'ers (Ted Faber in particular), and my friend Sanjay. BY VERSION Other contributions follow based on version. If you contributed something and you are not listed here, let me know, it's easy to forget to list people. Also note that if you're in the Changelog, you may not be here: 2.1 - Thanks to Brian Nelson for find the -sSdD bug quickly before everyone had packaged 2.0! 2.0 - Thanks to Ted Faber for his extensive coding knowledge - Thanks to Garrick Stapples for his help figuring out ncurses pads and scrolling - Thanks Bill Hudacek for the formatting bug report. 1.4 - 1.3 - Steve Augart finally proved the memory leak was in ncurses. Just in the nick of time before Debian kicked ipstate out. Extra special mega thanks to you Steve! Others who helped were Julian Seward, Todd Lyons, and many suggestions from various folks on the UUASC and USCLUG mailing lists. - Todd Lyons pointed out snprintf's in printline function should allow an extra char so as not to cut off newlines. 1.2.1 - Thanks to Martin Geisler for pointing out the typo in the man page 1.2.0 - Thanks to Garrick for all your help troubleshooting and beta testing. 1.1.0 - Beat Bolli sent in a large patch that was a reference to finish up much of the work I was doing for this version such as fixing TTL sort, and various simplifications. His patch also reminded me to do the -R option, notified me of the 'make uninstall' bug, and gave a few cleanups. - Blars Blarson sent a patch to the Debian developers noting that I was only reading in 50 connections. He also sent in a patch to print a newline upon exiting state-top mode so the prompt isn't mixed in left- over output. - Many others made patches that did some of the above things in countless ways... 1.0.1 - Thanks to Garrick Staples for the .spec file Phil Dibowitz phil AT ipom DOT com iptstate-2.3.0/LICENSE000066400000000000000000000023111521561511100143510ustar00rootroot00000000000000 IP Tables State (iptstate) Copyright (C) 2002 - present Phil Dibowitz This software is provided 'as-is', without any express or implied warranty. In no event will the authors be held liable for any damages arising from the use of this software. Permission is granted to anyone to use this software for any purpose, including commercial applications, and to alter it and redistribute it freely, subject to the following restrictions: 1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. 2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. 3. This notice may not be removed or altered from any source distribution. ----------------------------------- NOTE: If you are planning on packaging and/or submitting my software for/to a Linux distribution, I would appreciate a heads up. There is already an official maintainer for most popular distributions, see the CONTRIB file for details. Phil Dibowitz phil AT ipom DOT com iptstate-2.3.0/Makefile000066400000000000000000000044661521561511100150210ustar00rootroot00000000000000# # Copyright (C) 2002 - present Phil Dibowitz. # # See iptstate.cc for copyright info # # Makefile for IPTState # ### USERS CAN CHANGE STUFF HERE PREFIX?=/usr SBIN?=$(PREFIX)/sbin INSTALL?=/usr/bin/install STRIP?=/usr/bin/strip MAN?=$(PREFIX)/share/man PKG_CONFIG?=pkg-config ### ADVANCED USERS AND PACKAGERS MIGHT WANT TO CHANGE THIS CXX?= g++ # All of our snprintf()s have size limits and are not a security issue, # but having to modulo every hours/second/minute variable in every snprintf # is the only way to work around format-truncation warning which is cumbersome # and hard to read. Hence -Wformat-truncation=0 CXXFLAGS?= -g -Wall -O2 -Werror=format-security -Wformat-truncation=0 CXXFILES?= iptstate.cc # THIS IS FOR NORMAL COMPILATION LIBS?= $(shell $(PKG_CONFIG) --libs ncurses libnetfilter_conntrack) ### YOU SHOULDN'T NEED TO CHANGE ANYTHING BELOW THIS all: iptstate iptstate: iptstate.cc Makefile @\ echo "+------------------------------------------------------------+" ;\ echo "| Welcome to IP Tables State by Phil Dibowitz |" ;\ echo "| |" ;\ echo "| PLEASE read the LICENSE and the README for important info. |" ;\ echo "| |" ;\ echo "| You may also wish to read the README for install info, |" ;\ echo "| the WISHLIST for upcoming features, BUGS for known bugs |" ;\ echo "| and info on bug reports, and the Changelog to find out |" ;\ echo "| what's new. |" ;\ echo "| |" ;\ echo "| Let's compile... |" ;\ echo "+------------------------------------------------------------+" ;\ echo ""; $(CXX) $(CPPFLAGS) $(CXXFLAGS) $(LDFLAGS) $(CXXFILES) -o iptstate $(LIBS) @touch iptstate @\ echo "" ;\ echo "All done. Do 'make install' as root and you should be set to go!" ;\ echo "" strip: iptstate $(STRIP) iptstate @touch strip install: $(INSTALL) -D --mode=755 iptstate $(SBIN)/iptstate $(INSTALL) -D --mode=444 iptstate.8 $(MAN)/man8/iptstate.8 clean: /bin/rm -rf iptstate /bin/rm -rf strip uninstall: /bin/rm -rf $(SBIN)/iptstate /bin/rm -rf $(MAN)/man1/iptstate.1 /bin/rm -rf $(MAN)/man8/iptstate.8 iptstate-2.3.0/README.md000066400000000000000000000136661521561511100146420ustar00rootroot00000000000000# IP Tables State (iptstate) [![Lint]( https://github.com/jaymzh/iptstate/workflows/Lint/badge.svg )](https://github.com/jaymzh/iptstate/actions?query=workflow%3ALint) [![Build]( https://github.com/jaymzh/iptstate/workflows/Build/badge.svg )](https://github.com/jaymzh/iptstate/actions?query=workflow%3ABuild) Please see the LICENSE file for license information. ## WHAT IS IP TABLES STATE? IP Tables State (iptstate) was originally written to implement the "state top" feature of IP Filter (see "The Idea" below) in IP Tables. "State top" displays the states held by your stateful firewall in a top-like manner. Since IP Tables doesn't have a built in way to easily display this information even once, an option was added to just have it display the state table once. Features include: * Top-like realtime state table information * Sorting by any field * Reversible sorting * Single display of state table * Customizable refresh rate * Display filtering * Color-coding * Open Source (specifically I'm using the zlib license) * much more... You can checkout some [screenshots](SCREENSHOTS.md). ## INSTALATION IPTState is packaged in most Linux distributions. If your distribution is in the table below, your best bet is so use your distro's package manager to install it. [![Packaging status]( https://repology.org/badge/vertical-allrepos/iptstate.svg?exclude_unsupported=1 )](https://repology.org/project/iptstate/versions) Otherwise, you can build it from source. ### Building: prerequisites Make sure you have some version of curses installed (for most users this is probably ncurses). Note that if you are using vendor packages you will most likely need the packaged with '-dev' on the end of of it (i.e. ncurses-dev). Starting with version 2.2.0, you also need libnetfilter_conntrack version 0.0.50 or later. These libraries also require nf_conntrack_netlink and nfnetlink support in your kernel. You will also need pkg-config at build-time. ### Building: the quick version: For most people the following should do all you need: ```shell make make install # this must be done as root ``` ### Building: the long version: #### Configuration The program is only one c++ source file, so the compile is very simple. For this reason there is no config file. The defaults in the Makefile should be fine, but if you want to change something you can change where iptstate gets installed by changing the "SBIN" variable in your environment. I can't imagine a reason but if you have 'install' installed in a weird place change the INSTALL variable in your environment. Other than that nothing should need tweaking. Obviously advanced users may wish to do other stuff, but we'll leave that as an excersize to the reader. #### Compiling The compiling should be as simple as running 'make.' If this doesn't work, feel free to drop me an email, BUT MAKE SURE you put "IPTSTATE:" in the subject. In the email include: Distribution, kernel version, make version, gcc version, libc version, and the error messages. Package maintainers may wish to override CXXFLAGS, and can do so like so: ```shell # CXXFLAGS=-O3 make ``` and/or use "make strip" which will build iptstate and then strip it. If you get errors like: ```shell iptstate.cc:286: passing `in_addr *' as argument 1 of `gethostbyaddr(const char *, size_t, int)' ``` then you need to upgrade your glibc. This is an important thing to keep up-to-date anyway. #### Installing IPTState installs in /usr/sbin. This is because it should be a utility for the superuser. You need root access (or CAP_NET_ADMIN) for iptstate to get the data it needs anyway. Installing should be as simple as 'make install' as root. If this fails, feel free to do: ```shell # cp iptstate /usr/sbin/iptstate # chmod 755 /usr/sbin/iptstate # chown root:bin /usr/sbin/iptstate # cp iptstate.8 /usr/share/man/man8/iptstate.8 # chmod 444 /usr/share/man/man1/iptstate.8 ``` And that should do it. If 'make install' fails feel free to drop me an email provided you put "IPTSTATE:" in the subject. Please see the BUGS file on how to send proper bug reports. ## USAGE IPTables State is extremely simple to use. Most of the time what you'll want is just the command 'iptstate' as root. This will launch you into the 'statetop' mode. In here, your state table is being sorted by Source IP. To change the sorting, on the fly, type 'b.' This will rotate through the various sorting possibilities. You can quit by typing 'q.' You can also change the sorting with the -b ("sort BY") option. The -b option takes d (Destination IP), D (Destination Port), S (Source IP), p (protocol), s (state), and t (TTL) as it's possible options. To sort by Source IP, just don't specify -b. You can also change the refresh rate of the statetop by -R followed by an integer. The integer represents the refresh rate in seconds. To get help, hit 'h' from withint iptstate, or run iptstate with the '--help' option. To get a quick look at what's going across your firewall, try iptstate -1. This is "single run" mode. It will just print out your state table at the moment you requested it. This is where -b comes in handy. Again, the default sort is by Source IP. NOTE WELL: This is not meant to be a comprehensive guide. There are many other features - check the man page, the -h option, and the interactive help page within iptstate for more information. But this should give you the basics. ## DESIRED FEATURES There is a list of features I plan and don't plan to implement in the WISHLIST file. ## THE IDEA The idea of statetop comes from IP Filter by Darren Reed. This package's main purpose is to provide a state-top type interface for IP Tables. I've added in the "single run" option since there's no nice way to do that with IP Tables either. ## THE AUTHOR IPTState was written by me, Phil Dibowitz. My day job is large-scale system administration and automation. Outside of work I maintain several open source projects. You can find out more about me at [PhilDev](http://www.phildev.net/). Phil Dibowitz phil AT ipom DOT com iptstate-2.3.0/RELEASE_PROCESS.md000066400000000000000000000005361521561511100161530ustar00rootroot00000000000000# Release process ## Bump version ```shell vi iptstate.cc iptstate.spec ``` ## Add appropriate Changelog entries ```shell vi Changelog ``` ## Commit & Push ## Tag a release ```shell version="2.2.7" # update accordingly git tag -a "v$version" -m "iptstate version $version" git push origin --tags ``` ## Create GH release ## Inform packagers iptstate-2.3.0/SCREENSHOTS.md000066400000000000000000000010751521561511100154740ustar00rootroot00000000000000# Screenshots ![IPTState 2.0 doing hostname lookups, with color-coding on (all one color because there's only TCP in this picture)](screenshots/iptstate-2.0-lookup-ss.png) ![IPTState 2.0 filtered to only show connections with a destination port of 22, doing color-coding, and host-name lookups.](screenshots/iptstate-2.0-filter-ss.png) ![IPTState 2.0 filtered to only show connections with a destination port of 22, doing color-coding, and host-name lookups.](screenshots/iptstate-2.0-help-ss.png) ![Original IPTState 1.2.0 screenshot](screenshots/iptstate-ss-old.png) iptstate-2.3.0/WISHLIST000066400000000000000000000011461521561511100145420ustar00rootroot00000000000000IPTSTATE WISHLIST Wishlist features should be filed in the Wishlist tracker on our sourceforge page. This is an overview of the common ones and where they are on the priority list. Features coming soon: - Filtering hostnames - Display NAT'd IP Features that may come later: - Secondary sorting - Display packets/bytes per interval instead of just total - Display the "CONNMARK" value of each connection Features I probably won't add because I'm not that interested, or don't feel they belong, or would be too much work, or some combination therein. - Full regex filtering Phil Dibowitz phil AT ipom DOT com iptstate-2.3.0/iptstate.8000066400000000000000000000202611521561511100152760ustar00rootroot00000000000000.\" Process this file with .\" groff -man -Tascii iptstate.8 .\" .TH IPTSTATE 8 "JUNE 2012" "" "" .\" .\" Man page written by Phil Dibowitz .\" .\" IPTState is copyright by Phil Dibowitz. Please see the README and LICENSE. .\" .SH NAME .B iptstate \- A top-like display of IP Tables state table entries .SH SYNOPSIS .B iptstate .RB [< options >] .SH DESCRIPTION .B iptstate displays information held in the IP Tables state table in real-time in a top-like format. Output can be sorted by any field, or any field reversed. Users can choose to have the output only print once and exit, rather than the top-like system. Refresh rate is configurable, IPs can be resolved to names, output can be formatted, the display can be filtered, and color coding are among some of the many features. .SH COMMAND\-LINE OPTIONS .TP .B -c, --no-color Toggle color-code by protocol .TP .B -C, --counters Toggle display of bytes/packets counters .TP .B -d, --dst-filter \fIIP[/NETMASK]\fP Only show states with a destination of \fIIP\fP and with optional \fINETMASK\fP. .br Note, that this must be an IP, hostname matching is not yet supported. .TP .B -D --dstpt-filter \fIport\fP Only show states with a destination port of \fIport\fP .TP .B -h, --help Show help message .TP .B -i, --invert-filters Invert filters to display non-matching results .TP .B -l, --lookup Show hostnames instead of IP addresses. Enabling this will also enable \fB-L\fP to prevent an ever-growing number of DNS requests. .TP .B -m, --mark-truncated Mark truncated hostnames with a '+' .TP .B -o, --no-dynamic Toggle dynamic formatting .TP .B -L, --no-dns Skip outgoing DNS lookup states .TP .B -f, --no-loopback Filter states on loopback .TP .B -p, --no-scroll No scrolling (don't use a "pad"). See \fBSCROLLING AND PADS\fP for more information. .TP .B -r, --reverse Reverse sort order .TP .B -R, --rate \fIseconds\fP Refresh rate, followed by rate in \fIseconds\fP. Note that this is for statetop mode, and not applicable for single-run mode (\-\-single). .TP .B -1, --single Single run (no curses) .TP .B -b, --sort \fIcolumn\fP This determines what column to sort by. Options: .br .B " S" Source Port .br .B " d" Destination IP (or Name) .br .B " D" Destination Port .br .B " p" Protocol .br .B " s" State .br .B " t" TTL .br .B " b" Bytes .br .B " P" Packets .br To sort by Source IP (or Name), don't use \-b. Sorting by bytes/packets is only available for kernels that support it, and only when compiled against libnetfilter_conntrack (the default). .TP .B -s, --src-filter \fIIP[/NETMASK]\fP Only show states with a source of \fIIP\fP and with optional \fINETMASK\fP. .br Note, that this must be an IP, hostname matching is not yet supported. .TP .B -S, --srcpt-filter \fIport\fP Only show states with a source port of \fIport\fP .TP .B -t, --totals Toggle display of totals .SH INTERACTIVE OPTIONS As of version 2.0, all command-line options are now available interactively using the same key as the short-option. For example, \fB--sort\fP is also \fB-b\fP, so while \fBiptstate\fP is running, hitting \fBb\fP will change the sorting to the next column. Similarly, \fBt\fP toggles the display of totals, and so on. .PP There are also extra interactive options: \fBB\fP - change sorting to previous column (opposite of \fBb\fP); \fBq\fP - quit; and \fBx\fP - delete the currently highlighted state from the netfilter conntrack table. .PP Additionally, the following keys are used to navigate within \fBiptstate\fP: .TP \fBUp\fP or \fBj\fP - Move up one line .TP \fBDown\fP or \fBk\fP - Move down one line .TP \fBLeft\fP or \fBh\fP - Move left one column .TP \fBRight\fP or \fBl\fP - Move right one column .TP \fBPageUp\fP or \fB^u\fP - Move up one page .TP \fBPageDown\fP or \fB^d\fP - Move down one page .TP \fBHome\fP - Go to the top .TP \fBEnd\fP - Go to the end .PP In many cases, \fBiptstate\fP needs to prompt you in order to change something. For example, if you want to set or change the source-ip filter, when you hit \fBs\fP, \fBiptstate\fP will pop up a prompt at the top of the window to ask you what you want to set it to. .PP Note that like many UNIX applications, ctrl-G will tell \fBiptstate\fP "nevermind" - it'll remove the prompt and forget you ever hit \fBs\fP. .PP In most cases, a blank response means "clear" - clear the source IP filter, for example. .PP At anytime while \fBiptstate\fP is running, you can hit \fBh\fP to get to the \fBinteractive help\fP which will display all the current settings to you as well give you a list of all interactive commands available. .PP While running, \fBspace\fP will immediately update the display. \fBIptstate\fP should gracefully handle all window resizes, but if it doesn't, you can force it to re-calculate and re-draw the screen with a \fBctrl-L\fP. .PP Note that hitting \fBl\fP to enable hostname resolution while in interactive mode will also enable \fBL\fP to skip all DNS entries (to prevent an ever-growing number of DNS requests). .SH SCROLLING AND PADS For almost any user, there is no reason to turn off scrolling. The ability to turn this off - and especially the ability to toggle this interactively - is done more for theoretical completeness than anything else. .TP But, nonetheless, here are the details. Typically in a curses application you create a "window." Windows don't scroll, however. They are, at most, the size of your terminal. Windows provide double-buffering to make refreshing as fast and seemless as possible. However, to enable scrolling, one has to use "pads" instead of windows. Pads can be bigger than the current terminal. Then all necessary data is written to the pad, and "scrolling" becomes a function of just showing the right part of that pad on the screen. .TP However, pads do not have the double-buffering feature that windows have. Thus, there _might_ be some case where for some user using some very strange machine, having scrolling enabled could cause poor refreshing. Given the nature of the way \fBiptstate\fP uses the screen though, I find this highly unlikely. In addition, the scrolling method uses a little more memory. However, \fBiptstate\fP is not a memory intensive application, so this shouldn't be a problem even on low-memory systems. .TP Nonetheless, if this does negatively affect you, the option to turn it off is there. .SH EXIT STATUS Anything other than 0 indicates and error. A list of current exit statuses are below: .TP .B 0 Success .TP .B 1 Bad command-line arguments .TP .B 2 Error communicating with the netfilter subsystem. .TP .B 3 Terminal too narrow .SH BUGS We don't support filtering on resolved names. IPv6 support is new and the dynamic formatting doesn't yet always handle IPv6 addresses as well as it should. .SH BUG REPORTS All bugs should be reported to Phil Dibowitz . Please see the \fBREADME\fR and \fBBUGS\fR for more information on bug reports. Please read the \fBWISHLIST\fR before sending in features you hope to see. .SH NOTES \fBiptstate\fP does a lot of work to try to fit everything on the screen in an easy-to-read way. However, in some cases, hostnames may need to be truncated (in lookup mode). Similarly, IPv6 addresses may need to be truncated. The truncation of names happens from the right for source because you most likely know your own domain name, and from the left for destination because knowing your users are connection to "mail.a." doesn't help much. However, for addresses, this is reversed. .PP \fBiptstate\fP does not automatically handle window-resizes while in the \fBinteractive help\fP screen. If you do resize while in this window, you should return to the main window, hit \fBctrl-L\fP to re-calculate and re-draw the screen, and then, if you choose, return to the \fBinteractive help\fP. .PP \fBiptstate\fP currently uses libnetfilter_conntrack to access the netfilter connection state table. However, older versions read out of /proc/net/ip_conntrack, and the current version can still be compiled to do this. This deprecated method can be racy on SMP systems, and can hurt performance on very heavily loaded firewalls. This deprecated method should be avoided - support will be removed in future versions. .SH SEE ALSO .BR iptables (8) .PP .SH AUTHOR \fBiptstate\fP was written by Phil Dibowitz .br http://www.phildev.net/iptstate/ iptstate-2.3.0/iptstate.cc000066400000000000000000002367531521561511100155330ustar00rootroot00000000000000/* * vim:textwidth=80:tabstop=2:shiftwidth=2:expandtab:ai * * iptstate.cc * IPTables State * * ----------------------------------- * * Copyright (C) 2002 - present Phil Dibowitz * * This software is provided 'as-is', without any express or * implied warranty. In no event will the authors be held * liable for any damages arising from the use of this software. * * Permission is granted to anyone to use this software for any * purpose, including commercial applications, and to alter it * and redistribute it freely, subject to the following restrictions: * * 1. The origin of this software must not be misrepresented; you * must not claim that you wrote the original software. If you use * this software in a product, an acknowledgment in the product * documentation would be appreciated but is not required. * * 2. Altered source versions must be plainly marked as such, and * must not be misrepresented as being the original software. * * 3. This notice may not be removed or altered from any source * distribution. * * ----------------------------------- * * The idea of statetop comes from IP Filter by Darren Reed. * * This package's main purpose is to provide a state-top type * interface for IP Tables. I've added in the "single run" * option since there's no nice way to do that either. * * NOTE: If you are planning on packaging and/or submitting my software for/to * a Linux distribution, I would appreciate a heads up. * */ #include #include #include #include #include #include #include #include #include #include #include #include // There are no C++-ified versions of these. #include #include extern "C" { #include }; #define __STDC_FORMAT_MACROS #include #include #include #include #include #include #include using namespace std; #define VERSION "2.3.0" /* * MAXCONS is set to 16k, the default number of states in iptables. Generally * speaking the ncurses pad is this many lines long, but since ncurses * uses a short for their dimensions, a pad can never be longer than 32767. * Thus we define both of these values and NLINES as the lesser of the two. */ #define MAXCONS 16384 #define MAXLINES 32767 #if MAXCONS < MAXLINES #define NLINES MAXCONS #else #define NLINES MAXLINES #endif #define MAXFIELDS 20 // This is the default format string if we don't dynamically determine it #define DEFAULT_FORMAT "%-21s %-21s %-7s %-12s %-9s\n" // The following MUST be the same as the above #define DEFAULT_SRC 21 #define DEFAULT_DST 21 #define DEFAULT_PROTO 7 #define DEFAULT_STATE 12 #define DEFAULT_TTL 9 // This is the format string for the "totals" line, always. #define TOTALS_FORMAT \ "Total States: %i -- TCP: %i UDP: %i ICMP: %i Other: %i (Filtered: %i)\n" // Options for truncating from the front or the back #define TRUNC_FRONT 0 #define TRUNC_END 1 // maxlength for string we pass to inet_ntop() #define NAMELEN 100 // Sorting options #define SORT_SRC 0 #define SORT_SRC_PT 1 #define SORT_DST 2 #define SORT_DST_PT 3 #define SORT_PROTO 4 #define SORT_STATE 5 #define SORT_TTL 6 #define SORT_BYTES 7 #define SORT_PACKETS 8 #define SORT_MAX 8 /* * GLOBAL CONSTANTS */ /* * GLOBAL VARS */ int sort_factor = 1; bool need_resize = false; /* shameless stolen from libnetfilter_conntrack_tcp.c */ static const char *states[] = { "NONE", "SYN_SENT", "SYN_RECV", "ESTABLISHED", "FIN_WAIT", "CLOSE_WAIT", "LAST_ACK", "TIME_WAIT", "CLOSE", "LISTEN" }; /* * STRUCTS */ // One state-table entry struct tentry_t { string proto, state, ttl, sname, dname, spname, dpname; in6_addr src, dst; uint8_t family; unsigned long srcpt, dstpt, bytes, packets, s; }; // x/y of the terminal window struct screensize_t { unsigned int x, y; }; // Struct 'o flags struct flags_t { bool single, totals, lookup, skiplb, staticsize, skipdns, tag_truncate, filter_src, filter_dst, filter_srcpt, filter_dstpt, filter_inv, noscroll, nocolor, counters; }; // Struct 'o counters struct counters_t { unsigned int total, tcp, udp, icmp, other, skipped; }; // Various filters to be applied pending the right flags in flags_t struct filters_t { in6_addr src, dst; bool has_srcnet, has_dstnet; uint8_t srcnet, dstnet; uint8_t srcfam, dstfam; unsigned long srcpt, dstpt; }; // The max-length of fields in the stable table struct max_t { unsigned int src, dst, proto, state, ttl; unsigned long bytes, packets; }; struct hook_data { vector *stable; flags_t *flags; max_t *max; counters_t *counts; const filters_t *filters; }; /* * GENERAL HELPER FUNCTIONS */ /* * split a string into two strings based on the first occurance * of any character */ void split(char s, string line, string &p1, string &p2) { int pos = line.find(s); p1 = line.substr(0, pos); p2 = line.substr(pos+1, line.size()-pos); } /* * split a string into an array of strings based on * any character */ void splita(char s, string line, vector &result) { int pos, size; int i=0; string temp, temp1; temp = line; while ((temp.find(s) != string::npos) && (i < MAXFIELDS-1)) { pos = temp.find(s); result[i] = temp.substr(0, pos); size = temp.size(); temp = temp.substr(pos+1, size-pos-1); if (result[i] != "") { i++; } } result[i] = temp; } /* * This determines the length of an integer (i.e. number of digits) */ unsigned int digits(unsigned long x) { return (unsigned int) floor(log10((double)x))+1; } /* * Check to ensure an IP & netmask are valid */ bool check_ip(const char *arg, in6_addr *addr, uint8_t *family, uint8_t *netmask, bool *has_netmask) { const char *p_arg; char ip[NAMELEN]; // Check for netmask prefix p_arg = strrchr(arg, '/'); if (p_arg == NULL) { memcpy(ip, arg, (strlen(arg) + 1)); *has_netmask = false; } else { size_t ip_len = strlen(arg) - strlen(p_arg); memcpy(ip, arg, ip_len); ip[ip_len] = '\0'; const char *net_arg = arg + ip_len + 1; if (net_arg[0] == '\0') return false; int net_int = atoi(net_arg); if (net_int < 0 || net_int > 128) return false; // Max IPv6 prefix length *has_netmask = true; *netmask = (uint8_t) net_int; } // Get IP int ret; ret = inet_pton(AF_INET6, ip, addr); if (ret) { *family = AF_INET6; return true; } ret = inet_pton(AF_INET, ip, addr); if (ret) { if (*has_netmask && *netmask > 32) return false; // Max IPv4 prefix length *family = AF_INET; return true; } return false; } /* * Compare IPv4/6 addresses with a netmask * https://gist.github.com/duedal/b83303b4988a4afb2a75 */ bool match_netmask(uint8_t family, const in6_addr &address, const in6_addr &network, uint8_t bits) { if (family == AF_INET) { if (bits == 0) { // C99 6.5.7 (3): u32 << 32 is undefined behaviour return true; } struct in_addr addr4, net4; memcpy(&addr4, &address, sizeof(in_addr)); memcpy(&net4, &network, sizeof(in_addr)); return !((addr4.s_addr ^ net4.s_addr) & htonl(0xFFFFFFFFu << (32 - bits))); } else { const uint32_t *a = address.s6_addr32; const uint32_t *n = network.s6_addr32; int bits_whole, bits_incomplete; bits_whole = bits >> 5; // number of whole u32 bits_incomplete = bits & 0x1F; // number of bits in incomplete u32 if (bits_whole) { if (memcmp(a, n, bits_whole << 2)) { return false; } } if (bits_incomplete) { uint32_t mask = htonl((0xFFFFFFFFu) << (32 - bits_incomplete)); if ((a[bits_whole] ^ n[bits_whole]) & mask) { return false; } } return true; } return false; } /* * The help */ void version() { cout << "IPTables State Top Version " << VERSION << endl << endl; } void help() { cout << "IPTables State Top Version " << VERSION << endl; cout << "Usage: iptstate []\n\n"; cout << " -c, --no-color\n"; cout << "\tToggle color-code by protocol\n\n"; cout << " -C, --counters\n"; cout << "\tToggle display of bytes/packets counters\n\n"; cout << " -d, --dst-filter [/]\n"; cout << "\tOnly show states with a destination of and optional \n"; cout << "\tNote: Hostname matching is not yet supported.\n\n"; cout << " -D --dstpt-filter \n"; cout << "\tOnly show states with a destination port of \n\n"; cout << " -h, --help\n"; cout << "\tThis help message\n\n"; cout << " -i, --invert-filters\n"; cout << "\tInvert filters to display non-matching results\n\n"; cout << " -l, --lookup\n"; cout << "\tShow hostnames instead of IP addresses. Enabling this will also" << " enable\n\t-L to prevent an ever-growing number of DNS requests.\n\n"; cout << " -m, --mark-truncated\n"; cout << "\tMark truncated hostnames with a '+'\n\n"; cout << " -o, --no-dynamic\n"; cout << "\tToggle dynamic formatting\n\n"; cout << " -L, --no-dns\n"; cout << "\tSkip outgoing DNS lookup states\n\n"; cout << " -f, --no-loopback\n"; cout << "\tFilter states on loopback\n\n"; cout << " -p, --no-scroll\n"; cout << "\tNo scrolling (don't use a \"pad\")\n\n"; cout << " -r, --reverse\n"; cout << "\tReverse sort order\n\n"; cout << " -R, --rate \n"; cout << "\tRefresh rate, followed by rate in seconds\n"; cout << "\tNote: For statetop, not applicable for -s\n\n"; cout << " -1, --single\n"; cout << "\tSingle run (no curses)\n\n"; cout << " -b, --sort \n"; cout << "\tThis determines what column to sort by. Options:\n"; cout << "\t d: Destination IP (or Name)\n"; cout << "\t p: Protocol\n"; cout << "\t s: State\n"; cout << "\t t: TTL\n"; cout << "\t b: Bytes\n"; cout << "\t P: Packets\n"; cout << "\tTo sort by Source IP (or Name), don't use -b.\n"; cout << "\tNote that bytes/packets are only available when" << " supported in the kernel,\n"; cout << "\tand enabled with -C\n\n"; cout << " -s, --src-filter [/]\n"; cout << "\tOnly show states with a source of and optional \n"; cout << "\tNote: Hostname matching is not yet supported.\n\n"; cout << " -S, --srcpt-filter \n"; cout << "\tOnly show states with a source port of \n\n"; cout << " -t, --totals\n"; cout << "\tToggle display of totals\n\n"; cout << "See man iptstate(8) or the interactive help for more" << " information.\n"; exit(0); } /* * Resolve hostnames */ void resolve_host(const uint8_t &family, const in6_addr &ip, string &name) { struct hostent *hostinfo = NULL; if ((hostinfo = gethostbyaddr((char *)&ip, sizeof(ip), family)) != NULL) { name = hostinfo->h_name; } else { char str[NAMELEN]; name = inet_ntop(family, (void *)&ip, str, NAMELEN-1) ; } } void resolve_port(const unsigned int &port, string &name, const string &proto) { struct servent *portinfo = NULL; if ((portinfo = getservbyport(htons(port), proto.c_str())) != NULL) { name = portinfo->s_name; } else { ostringstream buf; buf.str(""); buf << port; name = buf.str(); } } /* * If lookup mode is on, we lookup the names and put them in the structure. * * If lookup mode is not on, we generate strings of the addresses and put * those in the structure. * * Finally, we update the max_t structure. * * NOTE: We stringify addresses largely because in the IPv6 case we need * to treat them like truncate-able strings. */ void stringify_entry(tentry_t *entry, max_t &max, const flags_t &flags) { unsigned int size = 0; ostringstream buffer; char tmp[NAMELEN]; bool have_port = entry->proto == "tcp" || entry->proto == "udp"; if (!have_port) { entry->spname = entry->dpname = ""; } if (flags.lookup) { resolve_host(entry->family, entry->src, entry->sname); resolve_host(entry->family, entry->dst, entry->dname); if (have_port) { resolve_port(entry->srcpt, entry->spname, entry->proto); resolve_port(entry->dstpt, entry->dpname, entry->proto); } } else { buffer << inet_ntop(entry->family, (void*)&(entry->src), tmp, NAMELEN-1); entry->sname = buffer.str(); buffer.str(""); buffer << inet_ntop(entry->family, (void*)&(entry->dst), tmp, NAMELEN-1); entry->dname = buffer.str(); buffer.str(""); if (have_port) { buffer << entry->srcpt; entry->spname = buffer.str(); buffer.str(""); buffer << entry->dstpt; entry->dpname = buffer.str(); buffer.str(""); } } size = entry->sname.size() + entry->spname.size() + 1; if (size > max.src) max.src = size; size = entry->dname.size() + entry->dpname.size() + 1; if (size > max.dst) max.dst = size; } /* * SORT FUNCTIONS */ bool src_sort(tentry_t *one, tentry_t *two) { /* * memcmp() will properly sort v4 or v6 addresses, but not cross-family * (presumably because of garbage in the top 96 bytes when you store * a v4 address in a in6_addr), so we sort by family and then memcmp() * within the same family. */ if (one->family == two->family) { return memcmp(one->src.s6_addr, two->src.s6_addr, 16) * sort_factor < 0; } else if (one->family == AF_INET) { return sort_factor > 0; } else { return sort_factor < 0; } } bool srcname_sort(tentry_t *one, tentry_t *two) { return one->sname.compare(two->sname) * sort_factor < 0; } bool dst_sort(tentry_t *one, tentry_t *two) { // See src_sort() for details if (one->family == two->family) { return memcmp(one->dst.s6_addr, two->dst.s6_addr, 16) * sort_factor < 0; } else if (one->family == AF_INET) { return sort_factor > 0; } else { return sort_factor < 0; } } bool dstname_sort(tentry_t *one, tentry_t *two) { return one->dname.compare(two->dname) * sort_factor < 0; } /* * int comparison that takes care of sort_factor * used for ports, bytes, etc... */ bool cmpint(int one, int two) { return (sort_factor > 0) ? one < two : one > two; } bool srcpt_sort(tentry_t *one, tentry_t *two) { return cmpint(one->srcpt, two->srcpt); } bool dstpt_sort(tentry_t *one, tentry_t *two) { return cmpint(one->dstpt, two->dstpt); } bool proto_sort(tentry_t *one, tentry_t *two) { return one->proto.compare(two->proto) * sort_factor < 0; } bool state_sort(tentry_t *one, tentry_t *two) { return one->state.compare(two->state) * sort_factor < 0; } bool ttl_sort(tentry_t *one, tentry_t *two) { return one->ttl.compare(two->ttl) * sort_factor < 0; } bool bytes_sort(tentry_t *one, tentry_t *two) { return cmpint(one->bytes, two->bytes); } bool packets_sort(tentry_t *one, tentry_t *two) { return cmpint(one->packets, two->packets); } /* * CURSES HELPER FUNCTIONS */ /* * Finish-up for curses environment */ void end_curses() { if (stdscr == NULL) return; curs_set(1); nocbreak(); endwin(); cout << endl; } /* * SIGWINCH signal handler. */ void winch_handler(int sig) { sigset_t mask_set; sigset_t old_set; // Reset signal handler signal(28, winch_handler); // ignore this signal for a bit sigfillset(&mask_set); sigprocmask(SIG_SETMASK, &mask_set, &old_set); need_resize = true; } /* * SIGKILL signal handler */ void kill_handler(int sig) { end_curses(); printf("Caught signal %d, cleaning up.\n", sig); exit(0); } /* * Start-up for curses environment * * NOTE: That by default we create a pad. A pad is a special type of window that * can be bigger than the screen. See the comments in interactive_help() * below for how to use it and how it works. * * However, pad's lack the double-buffering and other features of standard * ncurses windows and thus can appear slower. Thus we allow the user to * downgrade to standard windows if they choose. See the comments * switch_scroll() for more details. * */ static WINDOW* start_curses(flags_t &flags) { [[maybe_unused]] int y, x; initscr(); cbreak(); noecho(); halfdelay(1); /* * If we're starting curses, we care about SIGWNCH, SIGINT, and SIGTERM * so this seems like as good a place as any to setup our signal * handler. */ // Resize signal(28, winch_handler); // Shutdown signal(2, kill_handler); signal(15, kill_handler); if (has_colors()) { start_color(); // for tcp init_pair(1, COLOR_GREEN, COLOR_BLACK); // for udp init_pair(2, COLOR_YELLOW, COLOR_BLACK); // for icmp init_pair(3, COLOR_RED, COLOR_BLACK); // for prompts init_pair(4, COLOR_BLACK, COLOR_RED); // for the currently selected row init_pair(5, COLOR_BLACK, COLOR_GREEN); init_pair(6, COLOR_BLACK, COLOR_YELLOW); init_pair(7, COLOR_BLACK, COLOR_RED); } else { flags.nocolor = true; } if (!flags.noscroll) { getmaxyx(stdscr, y, x); return newpad(NLINES, x); } return stdscr; } /* * Figure out the best way to get the screensize_t, and then do it */ screensize_t get_size(const bool &single) { int maxx = 0, maxy = 0; if (!single) { getmaxyx(stdscr, maxy, maxx); } else { maxx = 72; struct winsize w; // try all 3 std filehandles since people may have pipe in/out of us for (int fd : {STDIN_FILENO, STDOUT_FILENO, STDERR_FILENO}) { if (ioctl(fd, TIOCGWINSZ, &w) == 0 && w.ws_col > 0) { maxx = w.ws_col; break; } } if (getenv("COLS")) maxx = atoi(getenv("COLS")); } screensize_t a; a.x = maxx; a.y = maxy; return a; } /* * Error function for screen being too small. */ void term_too_small() { end_curses(); cout << "I'm sorry, your terminal must be atleast 72 columns" << "wide to run iptstate\n"; exit(3); } /* * This is one of those "well, I should impliment it to be complete, but * I doubt it'll get used very often features." It was a nice-thing-to-do * to impliment the ability for iptstate to use stdscr instead of a pad * as this provides the doulbe-buffering and other features that pads * do not. This is probably useful to a small subset of users. It's pretty * unlikely people will want to interactively want to change this during * runtime, but since I implimented noscroll, it's only proper to impliment * interactive toggling. * * TECH NOTE: * This is just a note for myself so I remember why this is the way it is. * * The syntax WINDOW *&mainwin is right, thought it's doing what you'd * expect WINDOW &*mainwin to do... except that's invalid. So it's just a * &foo pass on a WINDOW*. */ void switch_scroll(flags_t &flags, WINDOW *&mainwin) { [[maybe_unused]] int x, y; if (flags.noscroll) { getmaxyx(stdscr, y, x); // remove stuff from the bottom window erase(); // build pad wmove(mainwin, 0, 0); mainwin = newpad(NLINES, x); wmove(mainwin, 0, 0); keypad(mainwin,1); halfdelay(1); } else { // delete pad delwin(mainwin); mainwin = stdscr; keypad(mainwin,1); halfdelay(1); } flags.noscroll = !flags.noscroll; } /* * Prompt the user for something, and get an answer. */ void get_input(WINDOW *win, string &input, const string &prompt, const flags_t &flags) { /* * This function is here so that we can prompt and get an answer * and the user can get an echo of what they're inputting. This is * already a non-straight-forward thing to do in cbreak() mode, but * it turns out that using pads makes it even more difficult. * * It's worth noting that I tried doin a simple waddch() and then * prefresh as one would expect, but it didn't echo the chars. * Because we're using pads I have to do a waddchar() and then * a prefresh(). * * Note, that the documentation says that if we're using waddchar() * we shouldn't need any refresh, but it doesn't echo without it. * This is probably because waddch() calls wrefresh() instead of * prefresh(). */ input = ""; [[maybe_unused]] int x, y; getmaxyx(stdscr, y, x); WINDOW *cmd = subpad(win, 1, x, 0, 0); if (!flags.nocolor) wattron(cmd, COLOR_PAIR(4)); keypad(cmd, true); wprintw(cmd, "%s", prompt.c_str()); wclrtoeol(cmd); prefresh(cmd, 0, 0, 0, 0, 0, x); int ch; int charcount = 0; echo(); nodelay(cmd,0); while (1) { ch = wgetch(cmd); switch (ch) { case '\n': // 7 is ^G case 7: if (ch == 7) input = ""; if (!flags.nocolor) wattroff(cmd, COLOR_PAIR(4)); delwin(cmd); noecho(); wmove(win, 0, 0); return; break; // on most platforms KEY_BACKSPACE will catch // all backspaces... case KEY_BACKSPACE: // but on some platforms ncurses fails, so ensure we catch both 8 (0x8) and 127 (0x7e) // which are the two valid backspace keycodes case 8: case 127: if (charcount > 0) { input = input.substr(0, input.size()-1); wechochar(cmd, '\b'); wechochar(cmd, ' '); wechochar(cmd, '\b'); charcount--; } break; case ERR: continue; break; default: input += ch; charcount++; wechochar(cmd, ch); } prefresh(cmd, 0, 0, 0, 0, 0, x); } } /* * Create a window with noticable colors (if colors are enabled) * and print a warning. Means curses_warning. */ void c_warn(WINDOW *win, const string &warning, const flags_t &flags) { /* * This function is here so that we can warn a user in curses, * usually about bad input. */ int x, y; getmaxyx(stdscr, y, x); WINDOW *warn = subpad(win, 1, x, 0, 0); if (!flags.nocolor) wattron(warn, COLOR_PAIR(4)); wprintw(warn, "%s", warning.c_str()); wprintw(warn, " Press any key to continue..."); wclrtoeol(warn); prefresh(warn, 0, 0, 0, 0, 0, x); while ((y = getch())) { if (y != ERR) { break; } prefresh(warn, 0, 0, 0, 0, 0, x); } if (!flags.nocolor) wattroff(warn, COLOR_PAIR(4)); delwin(warn); noecho(); wmove(win, 0, 0); return; } /* * Initialize the max_t structure with some sane defaults. We'll grow * them later as needed. */ void initialize_maxes(max_t &max, flags_t &flags) { /* * For NO lookup: * src/dst IP can be no bigger than 21 chars: * IP (max of 15) + colon (1) + port (max of 5) = 21 * * For lookup: * if it's a name, we start with the width of the header, and we can * grow from there as needed. */ if (flags.lookup) { max.src = 6; max.dst = 11; } else { max.src = max.dst = 21; } /* * The proto starts at 3, since tcp/udp are the most common, but will * grow if we see bigger proto strings such as "ICMP". */ max.proto = 3; /* * "ESTABLISHED" is generally the longest state, we almost always have * several, so we'll start with this. It also looks really bad if state * is changing size a lot, so we start with a common minumum. */ max.state = 11; // TTL we statically make 7: xxx:xx:xx max.ttl = 9; // Start with something sane max.bytes = 2; max.packets = 2; } /* * The actual work of handling a resize. */ void handle_resize(WINDOW *&win, const flags_t &flags, screensize_t &ssize) { if (flags.noscroll) { endwin(); refresh(); return; } /* * OK, the above case without pads is easy. But pads is tricker. * In order to properly handle SIGWINCH we need to: * * - Tear down the pad (delwin) * - Reset the terminal settings to non-visual mode (endwin) * - Return to visual mode (refresh) * - Get the new size (getmaxyx) * - Rebuild the pad * * Note that we don't get the new size without the endwin/refresh * and thus the new pad doesn't get built right, and everything wraps. * * This order must be preserved. */ /* * Tear down... */ delwin(win); endwin(); /* * Start up... */ refresh(); getmaxyx(stdscr, ssize.y, ssize.x); win = newpad(NLINES, ssize.x); keypad(win, true); wmove(win, 0, 0); return; } /* * Take in a 'curr' value, and delete a given conntrack */ void delete_state(WINDOW *&win, const tentry_t *entry, const flags_t &flags) { struct nfct_handle *cth; struct nf_conntrack *ct; cth = nfct_open(CONNTRACK, 0); ct = nfct_new(); int ret; string response; char str[NAMELEN]; string src, dst; src = inet_ntop(entry->family, (void *)&(entry->src), str, NAMELEN-1); dst = inet_ntop(entry->family, (void *)&(entry->dst), str, NAMELEN-1); ostringstream msg; msg.str(""); msg << "Deleting state: "; if (entry->proto == "tcp" || entry->proto == "udp") { msg << src << ":" << entry->srcpt << " -> " << dst << ":" << entry->dstpt; } else { msg << src << " -> " << dst; } msg << " -- Are you sure? (y/n)"; get_input(win, response, msg.str(), flags); if (response != "y" && response != "Y" && response != "yes" && response != "YES" && response != "Yes") { c_warn(win, "NOT deleting state.", flags); return; } nfct_set_attr_u8(ct, ATTR_ORIG_L3PROTO, entry->family); if (entry->family == AF_INET) { nfct_set_attr(ct, ATTR_ORIG_IPV4_SRC, (void *)&(entry->src.s6_addr)); nfct_set_attr(ct, ATTR_ORIG_IPV4_DST, (void *)&(entry->dst.s6_addr)); } else if (entry->family == AF_INET6) { nfct_set_attr(ct, ATTR_ORIG_IPV6_SRC, (void *)&(entry->src.s6_addr)); nfct_set_attr(ct, ATTR_ORIG_IPV6_DST, (void *)&(entry->dst.s6_addr)); } // undo our space optimization so the kernel can find the state. protoent *pn; if (entry->proto == "icmp6") pn = getprotobyname("ipv6-icmp"); else pn = getprotobyname(entry->proto.c_str()); nfct_set_attr_u8(ct, ATTR_ORIG_L4PROTO, pn->p_proto); if (entry->proto == "tcp" || entry->proto == "udp") { nfct_set_attr_u16(ct, ATTR_ORIG_PORT_SRC, htons(entry->srcpt)); nfct_set_attr_u16(ct, ATTR_ORIG_PORT_DST, htons(entry->dstpt)); } else if (entry->proto == "icmp" || entry->proto == "icmp6") { string type, code, id, tmp; split('/', entry->state, type, tmp); split(' ', tmp, code, tmp); split('(', tmp, tmp, id); split(')', id, id, tmp); nfct_set_attr_u8(ct, ATTR_ICMP_TYPE, atoi(type.c_str())); nfct_set_attr_u8(ct, ATTR_ICMP_CODE, atoi(code.c_str())); nfct_set_attr_u16(ct, ATTR_ICMP_ID, atoi(id.c_str())); } ret = nfct_query(cth, NFCT_Q_DESTROY, ct); if (ret < 0) { string msg = "Failed to delete state: "; msg += strerror(errno); c_warn(win, msg, flags); } } /* * CORE FUNCTIONS */ /* * Callback for conntrack */ int conntrack_hook(enum nf_conntrack_msg_type nf_type, struct nf_conntrack *ct, void *tmp) { /* * start by getting our struct back */ struct hook_data *data = static_cast(tmp); /* * and pull out the pieces */ vector *stable = data->stable; flags_t *flags = data->flags; max_t *max = data->max; counters_t *counts = data->counts; const filters_t *filters = data->filters; // our table entry unique_ptr entry(new tentry_t); // some vars struct protoent* pe = NULL; unsigned int seconds, minutes, hours; char ttlc[16]; ostringstream buffer; /* * Clear the entry */ entry->sname = ""; entry->dname = ""; entry->srcpt = 0; entry->dstpt = 0; entry->proto = ""; entry->ttl = ""; entry->state = ""; /* * First, we read stuff into the array that's always the * same regardless of protocol */ short int pr = nfct_get_attr_u8(ct, ATTR_ORIG_L4PROTO); pe = getprotobynumber(pr); if (pe == NULL) { buffer << pr; entry->proto = buffer.str(); buffer.str(""); } else { entry->proto = pe->p_name; /* * if proto is "ipv6-icmp" we can just say "icmp6" to save space... * it's more common/standard anyway */ if (entry->proto == "ipv6-icmp") entry->proto = "icmp6"; } // ttl seconds = nfct_get_attr_u32(ct, ATTR_TIMEOUT); minutes = seconds/60; hours = minutes/60; minutes = minutes%60; seconds = seconds%60; // Format it with snprintf and store it in the table snprintf(ttlc, sizeof(ttlc), "%3u:%02u:%02u", hours, minutes, seconds); entry->ttl = ttlc; entry->family = nfct_get_attr_u8(ct, ATTR_ORIG_L3PROTO); // Everything has addresses if (entry->family == AF_INET) { memcpy(entry->src.s6_addr, nfct_get_attr(ct, ATTR_ORIG_IPV4_SRC), sizeof(uint8_t[16])); memcpy(entry->dst.s6_addr, nfct_get_attr(ct, ATTR_ORIG_IPV4_DST), sizeof(uint8_t[16])); } else if (entry->family == AF_INET6) { memcpy(entry->src.s6_addr, nfct_get_attr(ct, ATTR_ORIG_IPV6_SRC), sizeof(uint8_t[16])); memcpy(entry->dst.s6_addr, nfct_get_attr(ct, ATTR_ORIG_IPV6_DST), sizeof(uint8_t[16])); } else { fprintf(stderr, "UNKNOWN FAMILY!\n"); exit(1); } // Counters (summary, in + out) entry->bytes = nfct_get_attr_u32(ct, ATTR_ORIG_COUNTER_BYTES) + nfct_get_attr_u32(ct, ATTR_REPL_COUNTER_BYTES); entry->packets = nfct_get_attr_u32(ct, ATTR_ORIG_COUNTER_PACKETS) + nfct_get_attr_u32(ct, ATTR_REPL_COUNTER_PACKETS); if (digits(entry->bytes) > max->bytes) { max->bytes = digits(entry->bytes); } if (digits(entry->packets) > max->packets) { max->packets = digits(entry->packets); } if (entry->proto.size() > max->proto) max->proto = entry->proto.size(); // OK, proto dependent stuff if (entry->proto == "tcp" || entry->proto == "udp") { entry->srcpt = htons(nfct_get_attr_u16(ct, ATTR_ORIG_PORT_SRC)); entry->dstpt = htons(nfct_get_attr_u16(ct, ATTR_ORIG_PORT_DST)); } if (entry->proto == "tcp") { entry->state = states[nfct_get_attr_u8(ct, ATTR_TCP_STATE)]; counts->tcp++; } else if (entry->proto == "udp") { entry->state = ""; counts->udp++; } else if (entry->proto == "icmp" || entry->proto == "icmp6") { buffer.str(""); buffer << (int)nfct_get_attr_u8(ct, ATTR_ICMP_TYPE) << "/" << (int)nfct_get_attr_u8(ct, ATTR_ICMP_CODE) << " (" << nfct_get_attr_u16(ct, ATTR_ICMP_ID) << ")"; entry->state = buffer.str(); counts->icmp++; if (entry->state.size() > max->state) max->state = entry->state.size(); } else { counts->other++; } /* * FILTERING */ /* * FIXME: Filtering needs to be pulled into it's own function. */ struct in_addr lb; struct in6_addr lb6; inet_pton(AF_INET, "127.0.0.1", &lb); inet_pton(AF_INET6, "::1", &lb6); size_t entrysize = entry->family == AF_INET ? sizeof(in_addr) : sizeof(in6_addr); if (flags->skiplb && (entry->family == AF_INET ? !memcmp(&(entry->src), &lb, sizeof(in_addr)) : !memcmp(&(entry->src), &lb6, sizeof(in6_addr)))) { counts->skipped++; return NFCT_CB_CONTINUE; } if (flags->skipdns && (entry->dstpt == 53)) { counts->skipped++; return NFCT_CB_CONTINUE; } if (flags->filter_src && !filters->has_srcnet) { if ((flags->filter_inv && !memcmp(&(entry->src), &(filters->src), entrysize)) || (!flags->filter_inv && memcmp(&(entry->src), &(filters->src), entrysize))) { counts->skipped++; return NFCT_CB_CONTINUE; } } if (flags->filter_src && filters->has_srcnet) { if ((flags->filter_inv && match_netmask(entry->family, entry->src, filters->src, filters->srcnet)) || (!flags->filter_inv && !match_netmask(entry->family, entry->src, filters->src, filters->srcnet))) { counts->skipped++; return NFCT_CB_CONTINUE; } } if (flags->filter_srcpt) { if ((flags->filter_inv && entry->srcpt == filters->srcpt) || (!flags->filter_inv && entry->srcpt != filters->srcpt)) { counts->skipped++; return NFCT_CB_CONTINUE; } } if (flags->filter_dst && !filters->has_dstnet) { if ((flags->filter_inv && !memcmp(&(entry->dst), &(filters->dst), entrysize)) || (!flags->filter_inv && memcmp(&(entry->dst), &(filters->dst), entrysize))) { counts->skipped++; return NFCT_CB_CONTINUE; } } if (flags->filter_dst && filters->has_dstnet) { if ((flags->filter_inv && match_netmask(entry->family, entry->dst, filters->dst, filters->dstnet)) || (!flags->filter_inv && !match_netmask(entry->family, entry->dst, filters->dst, filters->dstnet))) { counts->skipped++; return NFCT_CB_CONTINUE; } } if (flags->filter_dstpt) { if ((flags->filter_inv && entry->dstpt == filters->dstpt) || (!flags->filter_inv && entry->dstpt != filters->dstpt)) { counts->skipped++; return NFCT_CB_CONTINUE; } } /* * RESOLVE */ // Resolve names - if necessary - or generate strings of address, // and calculate max sizes stringify_entry(entry.get(), *max, *flags); /* * Add this to the array */ stable->push_back(entry.release()); return NFCT_CB_CONTINUE; } /** * Nuke the tentry_t's we made before deleting the vector of pointers */ void clear_table(vector &stable) { for (tentry_t* entry: stable) { delete entry; } stable.clear(); } /* * This is the core of this program - build a table of states. * * For the new libnetfilter_conntrack code, the bulk of build_table was moved * to the conntrack callback function. */ void build_table(flags_t &flags, const filters_t &filters, vector &stable, counters_t &counts, max_t &max) { /* * Variables */ int res=0; vector fields(MAXFIELDS); static struct nfct_handle *cth; u_int8_t family = AF_UNSPEC; /* * This is the ugly struct for the nfct hook, that holds pointers to * all of the things the callback will need to fill our table */ struct hook_data hook; hook.stable = &stable; hook.flags = &flags; hook.max = &max; hook.counts = &counts; hook.filters = &filters; /* * Initialization */ clear_table(stable); counts.tcp = counts.udp = counts.icmp = counts.other = counts.skipped = 0; cth = nfct_open(CONNTRACK, 0); if (!cth) { end_curses(); printf("ERROR: couldn't establish conntrack connection\n"); exit(2); } nfct_callback_register(cth, NFCT_T_ALL, conntrack_hook, (void *)&hook); res = nfct_query(cth, NFCT_Q_DUMP, &family); if (res < 0) { end_curses(); printf("ERROR: Couldn't retreive conntrack table: %s\n", strerror(errno)); exit(2); } nfct_close(cth); } /* * This sorts the table based on the current sorting preference */ void sort_table(const int &sortby, const bool &lookup, const int &sort_factor, vector &stable, string &sorting) { switch (sortby) { case SORT_SRC: if (lookup) { std::sort(stable.begin(), stable.end(), srcname_sort); sorting = "SrcName"; } else { std::sort(stable.begin(), stable.end(), src_sort); sorting = "SrcIP"; } break; case SORT_SRC_PT: std::sort(stable.begin(), stable.end(), srcpt_sort); sorting = "SrcPort"; break; case SORT_DST: if (lookup) { std::sort(stable.begin(), stable.end(), dstname_sort); sorting = "DstName"; } else { std::sort(stable.begin(), stable.end(), dst_sort); sorting = "DstIP"; } break; case SORT_DST_PT: std::sort(stable.begin(), stable.end(), dstpt_sort); sorting = "DstPort"; break; case SORT_PROTO: std::sort(stable.begin(), stable.end(), proto_sort); sorting = "Prt"; break; case SORT_STATE: std::sort(stable.begin(), stable.end(), state_sort); sorting = "State"; break; case SORT_TTL: std::sort(stable.begin(), stable.end(), ttl_sort); sorting = "TTL"; break; case SORT_BYTES: std::sort(stable.begin(), stable.end(), bytes_sort); sorting = "Bytes"; break; case SORT_PACKETS: std::sort(stable.begin(), stable.end(), packets_sort); sorting = "Packets"; break; default: //we should never get here sorting = "??unknown??"; break; } //switch if (sort_factor == -1) sorting = sorting + " reverse"; } void print_headers(const flags_t &flags, const string &format, const string &sorting, const filters_t &filters, const counters_t &counts, const screensize_t &ssize, int table_size, WINDOW *mainwin) { if (flags.single) { cout << "IP Tables State Top -- Sort by: " << sorting << endl; } else { wmove(mainwin, 0, 0); wclrtoeol(mainwin); wmove(mainwin,0, ssize.x/2-15); wattron(mainwin, A_BOLD); wprintw(mainwin, "IPTState - IPTables State Top\n"); wprintw(mainwin, "Version: "); wattroff(mainwin, A_BOLD); wprintw(mainwin, "%-13s", VERSION); wattron(mainwin, A_BOLD); wprintw(mainwin, "Sort: "); wattroff(mainwin, A_BOLD); wprintw(mainwin, "%-16s", sorting.c_str()); wattron(mainwin, A_BOLD); wprintw(mainwin, "b"); wattroff(mainwin, A_BOLD); wprintw(mainwin, "%-19s", ": change sorting"); wattron(mainwin, A_BOLD); wprintw(mainwin, "h"); wattroff(mainwin, A_BOLD); wprintw(mainwin, "%-s\n", ": help"); } /* * If enabled, print totals */ if (flags.totals) { if (flags.single) printf(TOTALS_FORMAT, table_size+counts.skipped, counts.tcp, counts.udp, counts.icmp, counts.other, counts.skipped); else wprintw(mainwin, TOTALS_FORMAT, table_size+counts.skipped, counts.tcp, counts.udp, counts.icmp, counts.other, counts.skipped); } /* * If any, print filters */ char tmp[NAMELEN]; if (flags.filter_src || flags.filter_dst || flags.filter_srcpt || flags.filter_dstpt) { if (flags.single) { printf("Filters: "); } else { wattron(mainwin, A_BOLD); wprintw(mainwin, "Filters: "); wattroff(mainwin, A_BOLD); } bool printed_a_filter = false; if (flags.filter_src) { inet_ntop(filters.srcfam, &filters.src, tmp, NAMELEN-1); if (flags.single) printf("src: %s", tmp); else wprintw(mainwin, "src: %s", tmp); if (filters.has_srcnet) { if (flags.single) printf("/%" PRIu8, filters.srcnet); else wprintw(mainwin, "/%" PRIu8, filters.srcnet); } printed_a_filter = true; } if (flags.filter_srcpt) { if (printed_a_filter) { if (flags.single) printf(", "); else waddstr(mainwin, ", "); } if (flags.single) printf("sport: %lu", filters.srcpt); else wprintw(mainwin, "sport: %lu", filters.srcpt); printed_a_filter = true; } if (flags.filter_dst) { if (printed_a_filter) { if (flags.single) printf(", "); else waddstr(mainwin, ", "); } inet_ntop(filters.dstfam, &filters.dst, tmp, NAMELEN-1); if (flags.single) printf("dst: %s", tmp); else wprintw(mainwin, "dst: %s", tmp); if (filters.has_dstnet) { if (flags.single) printf("/%" PRIu8, filters.dstnet); else wprintw(mainwin, "/%" PRIu8, filters.dstnet); } printed_a_filter = true; } if (flags.filter_dstpt) { if (printed_a_filter) { if (flags.single) printf(", "); else waddstr(mainwin, ", "); } if (flags.single) printf("dport: %lu", filters.dstpt); else wprintw(mainwin, "dport: %lu", filters.dstpt); printed_a_filter = true; } if (flags.filter_inv) { if (flags.single) { printf(" (Inverted)"); } else { wprintw(mainwin, " (Inverted)"); } } if (flags.single) printf("\n"); else wprintw(mainwin, "\n"); } /* * Print column headers */ if (flags.single) { if (flags.counters) printf(format.c_str(), "Source", "Destination", "Prt", "State", "TTL", "B", "P"); else printf(format.c_str(), "Source", "Destination", "Prt", "State", "TTL"); } else { wattron(mainwin, A_BOLD); if (flags.counters) wprintw(mainwin, format.c_str(), "Source", "Destination", "Prt", "State", "TTL", "B", "P"); else wprintw(mainwin, format.c_str(), "Source", "Destination", "Prt", "State", "TTL"); wattroff(mainwin, A_BOLD); } } void truncate(string &string, int length, bool mark, char direction) { int s = (direction == 'f') ? string.size() - length : 0; string = string.substr(s, length); if (mark) { int m = (direction == 'f') ? 0 : string.size() - 1; string[m] = '+'; } } /* * Based on the format pre-chosen, truncate src/dst as needed, and then * generate the host:port strings and drop them off in the src/dst string * objects passed in. */ void format_src_dst(tentry_t *table, string &src, string &dst, const flags_t &flags, const max_t &max) { ostringstream buffer; bool have_port = table->proto == "tcp" || table->proto == "udp"; char direction; unsigned int length; // What length would we currently use? length = table->sname.size(); if (have_port) length += table->spname.size() + 1; // If it's too long, figure out how room we have and truncate it if (length > max.src) { length = max.src; if (have_port) length -= 1 + table->spname.size(); direction = (flags.lookup) ? 'e' : 'f'; truncate(table->sname, length, flags.tag_truncate, direction); } // ... and repeat length = table->dname.size(); if (have_port) length += table->dpname.size() + 1; if (length > max.dst) { length = max.dst; if (have_port) length -= 1 + table->dpname.size(); direction = (flags.lookup) ? 'f' : 'e'; truncate(table->dname, length, flags.tag_truncate, direction); } buffer << table->sname; if (have_port) buffer << ":" << table->spname; src = buffer.str(); buffer.str(""); buffer << table->dname; if (have_port) buffer << ":" << table->dpname; dst = buffer.str(); buffer.str(""); } /* * An abstraction of priting a line for both single/curses modes */ void printline(tentry_t *table, const flags_t &flags, const string &format, const max_t &max, WINDOW *mainwin, const bool curr) { ostringstream buffer; buffer.str(""); string src, dst, b, p; // Generate strings for src/dest, truncating and marking as necessary format_src_dst(table, src, dst, flags, max); if (flags.counters) { buffer << table->bytes; b = buffer.str(); buffer.str(""); buffer << table->packets; p = buffer.str(); buffer.str(""); } if (flags.single) { if (flags.counters) printf(format.c_str(), src.c_str(), dst.c_str(), table->proto.c_str(), table->state.c_str(), table->ttl.c_str(), b.c_str(), p.c_str()); else printf(format.c_str(), src.c_str(), dst.c_str(), table->proto.c_str(), table->state.c_str(), table->ttl.c_str()); } else { int color = 0; if (!flags.nocolor) { if (table->proto == "tcp") color = 1; else if (table->proto == "udp") color = 2; else if (table->proto == "icmp" || table->proto == "icmp6") color = 3; if (curr) color += 4; wattron(mainwin, COLOR_PAIR(color)); } if (flags.counters) wprintw(mainwin, format.c_str(), src.c_str(), dst.c_str(), table->proto.c_str(), table->state.c_str(), table->ttl.c_str(), b.c_str(), p.c_str()); else wprintw(mainwin, format.c_str(), src.c_str(), dst.c_str(), table->proto.c_str(), table->state.c_str(), table->ttl.c_str()); if (!flags.nocolor && color != 0) wattroff(mainwin, COLOR_PAIR(color)); } } /* * This does all the work of actually printing the table including * various bits of formatting. It handles both curses and non-curses runs. */ void print_table(vector &stable, const flags_t &flags, const string &format, const string &sorting, const filters_t &filters, const counters_t &counts, const screensize_t &ssize, const max_t &max, WINDOW *mainwin, unsigned int &curr) { /* * Print headers */ print_headers(flags, format, sorting, filters, counts, ssize, stable.size(), mainwin); /* * Print the state table */ unsigned int limit = (stable.size() < NLINES) ? stable.size() : NLINES; for (unsigned int tmpint=0; tmpint < limit; tmpint++) { printline(stable[tmpint], flags, format, max, mainwin, (curr == tmpint)); if (!flags.single && flags.noscroll && (tmpint >= ssize.y-4 || (flags.totals && tmpint >= ssize.y-5))) break; } /* * We don't want to lave things on the screen we didn't draw * this time. */ if (!flags.single) wclrtobot(mainwin); } /* * Dynamically build a format to fit the most amount of data on the screen */ void determine_format(WINDOW *mainwin, max_t &max, screensize_t &ssize, string &format, flags_t &flags) { /* * NOTE: When doing proper dynamic format building, we fill the * entire screen, so curses puts in a newline for us. However * with "staticsize" we must add a newline. Also with "single" * mode we must add it as well since there's no curses there. * * Thus DEFAULT_FORMAT (only used for staticsize) has it, and * at the bottom of this function we add a \n if flags.single * is set. */ if (flags.staticsize) { format = DEFAULT_FORMAT; max.src = DEFAULT_SRC; max.dst = DEFAULT_DST; max.proto = DEFAULT_PROTO; max.state = DEFAULT_STATE; max.ttl = DEFAULT_TTL; return; } ssize = get_size(flags.single); /* The screen must be 85 chars wide to be able to fit in * counters when we display IP addresses... * * in lookup mode, we can truncate names, but in IP mode, * truncation makes no sense, so we just disable counters if * we run into this. */ if (ssize.x < 85 && flags.counters && !flags.lookup) { string prompt = "Window too narrow for counters! Disabling."; if (flags.single) cerr << prompt << endl; else c_warn(mainwin, prompt, flags); flags.counters = false; } /* what's left is the above three, plus 4 spaces * (one between each of 5 fields) */ unsigned int left = ssize.x - max.ttl - max.state - max.proto - 4; if (flags.counters) left -= (max.bytes + max.packets + 2); /* * The rest is *prolly* going to be divided between src * and dst, so we see if that works. If 'left' is odd though * we give the extra space to src. */ unsigned int src, dst; src = dst = left / 2; bool left_odd = false; if ((left % 2) == 1) { left_odd = true; src++; } if ((max.src + max.dst) < left) { /* * This means we can fit without an truncation, but it doesn't * necessarily mean that we can just give half to src and half * to dst... so lets figure that out. */ if (max.src < src && max.dst < dst) { /* * This case applies if: * we're even and they both fit in left/2 * OR * we're odd and dst fits in left/2 * and src fits in left/2+1 * * Since we've already calculated src/dst that way * we just combine this check as they both require * the same outcome. */ } else if (left_odd && (src < left / 2) && (dst < left / 2 + 1)) { /* * If src can fit in left/2 and dst in left/2+1 * then we switch them. */ src = dst; dst++; } else if (max.src > max.dst) { /* * If we're here, we can fit them, but we can't fit them * and still keep the two columns relatively equal. Ah * well. * * Either max gets the bigger chunk and everything else * to dst... */ src = max.src; dst = left - max.src; } else { /* * ...or the other way around */ dst = max.dst; src = left - max.dst; } } else if (max.src < src) { /* * If we're here, we do have to truncate, but if one column is * very small, we should not give it more space than it needs. */ src = max.src; dst = left - max.src; } else if (max.dst < dst) { /* * same as above. */ dst = max.dst; src = left - max.dst; } /* * If nothing matched, then they're both bigger than left/2, so we'll * leave the default we set above. */ ostringstream buffer; buffer << "\%-" << src << "s \%-" << dst << "s \%-" << max.proto << "s \%-" << max.state << "s \%-" << max.ttl << "s"; if (flags.counters) buffer << " \%-" << max.bytes << "s \%-" << max.packets << "s"; if (flags.single) buffer << "\n"; format = buffer.str(); max.dst = dst; max.src = src; } /* * Interactive help */ void interactive_help(const string &sorting, const flags_t &flags, const filters_t &filters) { /* * This is the max we need the pad to be, and thus how * big we're going to create the pad. * * In many cases we'd make the pad very very large and not * worry about it. However, in this case, we want to draw * a "box" around the window and if the pad is huge then * the box will get drawn around that. * * So... we have 41 lines of help, plus a top and bottom border, * thus maxrows is 43. We also need to account for the filter settings * that are only being displayed when enabled. * * Our help text is not wider than 80, so we'll set that standard * width. * * If the screen is bigger than this, we deal with it below. */ unsigned int maxrows = 43; unsigned int maxcols = 80; // Acount for dynamic filter settings maxrows += flags.filter_src + flags.filter_srcpt + flags.filter_dst + flags.filter_dstpt; /* * The actual screen size */ screensize_t ssize = get_size(flags.single); /* * If the biggest we think we'll need is smaller than the screen, * then lets grow the pad to the size of the screen so that the * main window isn't peeking through. */ if (maxrows < ssize.y) maxrows = ssize.y; if (maxcols < ssize.x) maxcols = ssize.x; /* * Where we are withing the pad (for printing). We can't just print * newlines and expect it to work. Cause, well, it doesn't. You have * to tell it where on the pad to print, specifically. */ unsigned int x, y; x = y = 0; /* * The current position on the pad we're showing (top left) */ unsigned int px, py; px = py = 0; /* * As noted above, we create the biggest pad we might need */ static WINDOW *helpwin; helpwin = newpad(maxrows, maxcols); /* * Create a box, and then add one to "x" and "y" so we don't write * on the line, */ box(helpwin, ACS_VLINE, ACS_HLINE); x++; y++; /* * we want arrow keys to work */ keypad(helpwin, true); // Prolly not needed wmove(helpwin, 0, 0); // Print opener wattron(helpwin, A_BOLD); mvwaddstr(helpwin, y++, x, "IPTState "); waddstr(helpwin, VERSION); wattroff(helpwin, A_BOLD); // this is \n y++; // We don't want anything except the title up against the // border x++; string nav = "Up/j, Down/k, Left/h, Right/l, PageUp/^u, PageDown/^d, "; nav += " Home, or End"; // Print instructions first mvwaddstr(helpwin, y++, x, "Navigation:"); mvwaddstr(helpwin, y++, x, nav.c_str()); mvwaddstr(helpwin, y++, x, " Press any other key to continue..."); y++; // Print settings mvwaddstr(helpwin, y++, x, "Current settings:"); mvwaddstr(helpwin, y++, x, " Sorting by: "); wattron(helpwin, A_BOLD); waddstr(helpwin, sorting.c_str()); wattroff(helpwin, A_BOLD); mvwaddstr(helpwin, y++, x, " Dynamic formatting: "); wattron(helpwin, A_BOLD); waddstr(helpwin,(!flags.staticsize) ? "yes" : "no"); wattroff(helpwin, A_BOLD); mvwaddstr(helpwin, y++, x, " Skip loopback states: "); wattron(helpwin, A_BOLD); waddstr(helpwin,(flags.skiplb) ? "yes" : "no"); wattroff(helpwin, A_BOLD); mvwaddstr(helpwin, y++, x, " Resolve hostnames: "); wattron(helpwin, A_BOLD); waddstr(helpwin,(flags.lookup) ? "yes" : "no"); wattroff(helpwin, A_BOLD); mvwaddstr(helpwin, y++, x, " Mark truncated hostnames: "); wattron(helpwin, A_BOLD); waddstr(helpwin,(flags.tag_truncate) ? "yes" : "no"); wattroff(helpwin, A_BOLD); mvwaddstr(helpwin, y++, x, " Colors: "); wattron(helpwin, A_BOLD); waddstr(helpwin,(!flags.nocolor) ? "yes" : "no"); wattroff(helpwin, A_BOLD); mvwaddstr(helpwin, y++, x, " Skip outgoing DNS lookup states: "); wattron(helpwin, A_BOLD); waddstr(helpwin,(flags.skipdns) ? "yes" : "no"); wattroff(helpwin, A_BOLD); mvwaddstr(helpwin, y++, x, " Enable scroll: "); wattron(helpwin, A_BOLD); waddstr(helpwin,(!flags.noscroll) ? "yes" : "no"); wattroff(helpwin, A_BOLD); mvwaddstr(helpwin, y++, x, " Display totals: "); wattron(helpwin, A_BOLD); waddstr(helpwin,(flags.totals) ? "yes" : "no"); wattroff(helpwin, A_BOLD); mvwaddstr(helpwin, y++, x, " Display counters: "); wattron(helpwin, A_BOLD); waddstr(helpwin,(flags.counters) ? "yes" : "no"); wattroff(helpwin, A_BOLD); mvwaddstr(helpwin, y++, x, " Invert filters: "); wattron(helpwin, A_BOLD); waddstr(helpwin,(flags.filter_inv) ? "yes" : "no"); wattroff(helpwin, A_BOLD); char tmp[NAMELEN]; if (flags.filter_src) { inet_ntop(filters.srcfam, &filters.src, tmp, NAMELEN-1); mvwaddstr(helpwin, y++, x, " Source filter: "); wattron(helpwin, A_BOLD); waddstr(helpwin, tmp); if (filters.has_srcnet) wprintw(helpwin, "/%" PRIu8, filters.srcnet); wattroff(helpwin, A_BOLD); } if (flags.filter_dst) { inet_ntop(filters.dstfam, &filters.dst, tmp, NAMELEN-1); mvwaddstr(helpwin, y++, x, " Destination filter: "); wattron(helpwin, A_BOLD); waddstr(helpwin, tmp); if (filters.has_dstnet) wprintw(helpwin, "/%" PRIu8, filters.dstnet); wattroff(helpwin, A_BOLD); } if (flags.filter_srcpt) { mvwaddstr(helpwin, y++, x, " Source port filter: "); wattron(helpwin, A_BOLD); wprintw(helpwin, "%lu", filters.srcpt); wattroff(helpwin, A_BOLD); } if (flags.filter_dstpt) { mvwaddstr(helpwin, y++, x, " Destination port filter: "); wattron(helpwin, A_BOLD); wprintw(helpwin, "%lu", filters.dstpt); wattroff(helpwin, A_BOLD); } y++; // Print commands mvwaddstr(helpwin, y++, x, "Interactive commands:"); wattron(helpwin, A_BOLD); mvwaddstr(helpwin, y++, x, " c"); wattroff(helpwin, A_BOLD); waddstr(helpwin, "\tUse colors"); wattron(helpwin, A_BOLD); mvwaddstr(helpwin, y++, x, " C"); wattroff(helpwin, A_BOLD); waddstr(helpwin, "\tToggle display of bytes/packets counters"); wattron(helpwin, A_BOLD); mvwaddstr(helpwin, y++, x, " b"); wattroff(helpwin, A_BOLD); waddstr(helpwin, "\tSort by next column"); wattron(helpwin, A_BOLD); mvwaddstr(helpwin, y++, x, " B"); wattroff(helpwin, A_BOLD); waddstr(helpwin, "\tSort by previous column"); wattron(helpwin, A_BOLD); mvwaddstr(helpwin, y++, x, " d"); wattroff(helpwin, A_BOLD); waddstr(helpwin, "\tChange destination filter"); wattron(helpwin, A_BOLD); mvwaddstr(helpwin, y++, x, " D"); wattroff(helpwin, A_BOLD); waddstr(helpwin, "\tChange destination port filter"); wattron(helpwin, A_BOLD); mvwaddstr(helpwin, y++, x, " f"); wattroff(helpwin, A_BOLD); waddstr(helpwin, "\tToggle display of loopback states"); wattron(helpwin, A_BOLD); mvwaddstr(helpwin, y++, x, " h"); wattroff(helpwin, A_BOLD); waddstr(helpwin, "\tDisplay this help message"); wattron(helpwin, A_BOLD); mvwaddstr(helpwin, y++, x, " i"); wattroff(helpwin, A_BOLD); waddstr(helpwin, "\tInvert filters to display non-matching results"); wattron(helpwin, A_BOLD); mvwaddstr(helpwin, y++, x, " l"); wattroff(helpwin, A_BOLD); waddstr(helpwin, "\tToggle DNS lookups"); wattron(helpwin, A_BOLD); mvwaddstr(helpwin, y++, x, " L"); wattroff(helpwin, A_BOLD); waddstr(helpwin, "\tToggle display of outgoing DNS states"); wattron(helpwin, A_BOLD); mvwaddstr(helpwin, y++, x, " m"); wattroff(helpwin, A_BOLD); waddstr(helpwin, "\tToggle marking truncated hostnames with a '+'"); wattron(helpwin, A_BOLD); mvwaddstr(helpwin, y++, x, " o"); wattroff(helpwin, A_BOLD); waddstr(helpwin, "\tToggle dynamic or old formatting"); wattron(helpwin, A_BOLD); mvwaddstr(helpwin, y++, x, " p"); wattroff(helpwin, A_BOLD); waddstr(helpwin, "\tToggle scrolling"); wattron(helpwin, A_BOLD); mvwaddstr(helpwin, y++, x, " q"); wattroff(helpwin, A_BOLD); waddstr(helpwin, "\tQuit"); wattron(helpwin, A_BOLD); mvwaddstr(helpwin, y++, x, " r"); wattroff(helpwin, A_BOLD); waddstr(helpwin, "\tToggle reverse sorting"); wattron(helpwin, A_BOLD); mvwaddstr(helpwin, y++, x, " R"); wattroff(helpwin, A_BOLD); waddstr(helpwin, "\tChange the refresh rate"); wattron(helpwin, A_BOLD); mvwaddstr(helpwin, y++, x, " s"); wattroff(helpwin, A_BOLD); waddstr(helpwin, "\tChange source filter"); wattron(helpwin, A_BOLD); mvwaddstr(helpwin, y++, x, " S"); wattroff(helpwin, A_BOLD); waddstr(helpwin, "\tChange source port filter"); wattron(helpwin, A_BOLD); mvwaddstr(helpwin, y++, x, " t"); wattroff(helpwin, A_BOLD); waddstr(helpwin, "\tToggle display of totals"); wattron(helpwin, A_BOLD); mvwaddstr(helpwin, y++, x, " x"); wattroff(helpwin, A_BOLD); waddstr(helpwin, "\tDelete the currently highlighted state from netfilter"); y++; wmove(helpwin, 0, 0); /* * refresh from wherever we are the pad * and the top of the window to the bottom of the window. */ prefresh(helpwin, py, px, 0, 0, ssize.y - 1, ssize.x - 1); // kill line buffering cbreak(); // nodelay with a 0 here causes getch() to block until key is pressed. nodelay( helpwin, 0 ); int c; while ((c = wgetch(helpwin))) { switch (c) { case ERR: continue; break; case KEY_DOWN: case 'j': /* * py is the top of the window, * ssize.y is the height of the window, * so py+ssize.y is the bottom of the window. * * Since y is the bottom of the text we've * written, if * py+ssize.y == y * then the bottom of the screen as at the * bottom of the text, no more scrolling. */ if (py + ssize.y < y) py++; prefresh(helpwin, py, px, 0, 0, ssize.y - 1, ssize.x - 1); break; case KEY_UP: case 'k': if (py > 0) py--; prefresh(helpwin, py, px, 0, 0, ssize.y - 1, ssize.x - 1); break; case KEY_RIGHT: case 'l': /* * px is the left of the window, * ssize.x is the width of the window, * so px+ssize.x os the right side of the window. * * So if px+ssize.x == 80 (more than the width * of our text), no more scrolling. */ if (px + ssize.x < 80) px++; prefresh(helpwin, py, px, 0, 0, ssize.y - 1, ssize.x - 1); break; case KEY_LEFT: case 'h': if (px > 0) px--; prefresh(helpwin, py, px, 0, 0, ssize.y - 1, ssize.x - 1); break; case KEY_HOME: case KEY_SHOME: case KEY_FIND: px = py = 0; prefresh(helpwin, py, px, 0, 0, ssize.y - 1, ssize.x - 1); break; case KEY_END: py = y-ssize.y; prefresh(helpwin, py, px, 0, 0, ssize.y - 1, ssize.x - 1); break; case 4: case KEY_NPAGE: case KEY_SNEXT: if (flags.noscroll) break; /* * If the screen is bigger than the text, * ignore */ if (y < ssize.y) break; /* * Otherwise, if the bottom of the screen * (current position + screen size * == py + ssize.y) * were to go down one screen (thus: * py + ssize.y*2), * and that is bigger than the whole text, just * go to the bottom. * * Otherwise, go down a screen size. */ if ((py + (ssize.y * 2)) > y) { py = y-ssize.y; } else { py += ssize.y; } prefresh(helpwin, py, px, 0, 0, ssize.y - 1, ssize.x - 1); break; case 21: case KEY_PPAGE: case KEY_SPREVIOUS: if (flags.noscroll) break; /* * If we're at the top, ignore this. */ if (py == 0) break; /* * Otherwise if we're less than a page from the * top, go to the top, else, go up a page. */ if (py < ssize.y) py = 0; else py -= ssize.y; prefresh(helpwin, py, px, 0, 0, ssize.y - 1, ssize.x - 1); break; case 'q': default: goto out; break; } if (need_resize) { goto out; } } out: // once a key is pressed, tear down the help window. delwin(helpwin); refresh(); halfdelay(1); } /* * MAIN */ int main(int argc, char *argv[]) { // Use the locale specified by the environment setlocale(LC_ALL, ""); // Variables string line, src, dst, srcpt, dstpt, proto, code, type, state, ttl, mins, secs, hrs, sorting, tmpstring, format, prompt; ostringstream ostream; vector stable; int tmpint = 0, sortby = 0, rate = 1, hdrs = 0; unsigned int py = 0, px = 0, curr_state = 0; timeval selecttimeout; fd_set readfd; flags_t flags; counters_t counts; screensize_t ssize; filters_t filters; max_t max; /* * Initialize */ flags.single = flags.totals = flags.lookup = flags.skiplb = flags.staticsize = flags.skipdns = flags.tag_truncate = flags.filter_src = flags.filter_dst = flags.filter_srcpt = flags.filter_dstpt = flags.noscroll = flags.nocolor = flags.counters = flags.filter_inv = false; ssize.x = ssize.y = 0; counts.tcp = counts.udp = counts.icmp = counts.other = counts.skipped = 0; filters.src = filters.dst = in6addr_any; filters.srcpt = filters.dstpt = 0; max.src = max.dst = max.proto = max.state = max.ttl = 0; px = py = 0; static struct option long_options[] = { {"counters", no_argument , 0, 'C'}, {"dst-filter", required_argument, 0, 'd'}, {"dstpt-filter", required_argument, 0, 'D'}, {"help", no_argument, 0, 'h'}, {"invert-filters", no_argument, 0, 'i'}, {"lookup", no_argument, 0, 'l'}, {"mark-truncated", no_argument, 0, 'm'}, {"no-color", no_argument, 0, 'c'}, {"no-dynamic", no_argument, 0, 'o'}, {"no-dns", no_argument, 0, 'L'}, {"no-loopback", no_argument, 0, 'f'}, {"no-scroll", no_argument, 0, 'p'}, {"rate", required_argument, 0, 'R'}, {"reverse", no_argument, 0, 'r'}, {"single", no_argument, 0, '1'}, {"sort", required_argument, 0, 'b'}, {"src-filter", required_argument, 0, 's'}, {"srcpt-filter", required_argument, 0, 'S'}, {"totals", no_argument, 0, 't'}, {"version", no_argument, 0, 'v'}, {0, 0, 0,0} }; int option_index = 0; // Command Line Arguments while ((tmpint = getopt_long(argc, argv, "Cd:D:hilmcoLfpR:r1b:s:S:tv", long_options, &option_index)) != EOF) { switch (tmpint) { case 0: /* Apparently this test is needed?! Seems lame! */ if (long_options[option_index].flag != 0) break; /* * Long-only options go here, like so: * * tmpstring = long_options[option_index].name; * if (tmpstring == "srcpt-filter") { * ... * } else if (...) { * ... * } * */ break; // --counters case 'C': flags.counters = true; break; // --dst-filter case 'd': if (optarg == NULL) break; // See check_ip() note above if (!check_ip(optarg, &filters.dst, &filters.dstfam, &filters.dstnet, &filters.has_dstnet)) { cerr << "Invalid IP address: " << optarg << endl; exit(1); } flags.filter_dst = true; break; // --dstpt-filter case 'D': /* * even though this won't be an IP address * aton() won't complain about anything that's * just digits, so it's an easy check. */ if (optarg == NULL) break; flags.filter_dstpt = true; filters.dstpt = atoi(optarg); break; // --invert-filters case 'i': flags.filter_inv = true; break; // --help case 'h': help(); break; // --lookup case 'l': flags.lookup = true; // and also set skipdns for sanity flags.skipdns = true; break; // --mark-truncated case 'm': flags.tag_truncate = true; break; // --color case 'c': flags.nocolor = false; break; // --no-dynamic case 'o': flags.staticsize = true; break; // --no-dns case 'L': flags.skipdns = true; break; // --no-loopback case 'f': flags.skiplb = true; break; // --no-scroll case 'p': flags.noscroll = true; break; // --reverse case 'r': sort_factor = -1; break; // --rate case 'R': rate = atoi(optarg); break; // --sort case 'b': if (*optarg == 'd') sortby = SORT_DST; else if (*optarg == 'D') { sortby = SORT_DST_PT; } else if (*optarg == 'S') sortby = SORT_SRC_PT; else if (*optarg == 'p') sortby = SORT_PROTO; else if (*optarg == 's') sortby = SORT_STATE; else if (*optarg == 't') sortby = SORT_TTL; else if (*optarg == 'b' && flags.counters) sortby = SORT_BYTES; else if (*optarg == 'P' && flags.counters) sortby = SORT_PACKETS; break; // --single case '1': flags.single = true; break; // --src-filter case 's': if (optarg == NULL) break; if (!check_ip(optarg, &filters.src, &filters.srcfam, &filters.srcnet, &filters.has_srcnet)) { cerr << "Invalid IP address: " << optarg << endl; exit(1); } flags.filter_src = true; break; // --srcpt-filter case 'S': if (optarg == NULL) break; flags.filter_srcpt = true; filters.srcpt = atoi(optarg); break; // --totals case 't': flags.totals = true; break; // --version case 'v': version(); exit(0); break; // catch-all default: // getopts should already have printed a message exit(1); break; } } if (rate < 0 || rate > 60) { rate = 1; } // Initialize Curses Stuff static WINDOW *mainwin = NULL; if (!flags.single) { mainwin = start_curses(flags); keypad(mainwin, true); } /* * We want to keep going until the user stops us * unless they use single run mode * in which case, we'll deal with that down below */ while (1) { /* * We get the screensize_t up-front so we can die if the * screen doesn't meet our minimum requirements without making * the user wait while we gather and process all the data. * We'll do it again afterwards just in case */ ssize = get_size(flags.single); if (ssize.x < 72) { term_too_small(); } // And our header size hdrs = 3; if (flags.totals) { hdrs++; } if (flags.filter_src || flags.filter_dst || flags.filter_srcpt || flags.filter_dstpt) { hdrs++; } // clear maxes initialize_maxes(max, flags); // Build our table build_table(flags, filters, stable, counts, max); /* * Now that we have the new table, make sure our page/cursor * positions still make sense. */ if (curr_state > stable.size() - 1) { curr_state = stable.size() - 1; } /* * The bottom of the screen is stable.size()+hdrs+1 * (the +1 is so we can have a blank line at the end) * but we want to never have py be more than that - ssize.y * so we're showing a page full of states. */ int bottom = stable.size() + hdrs + 1 - ssize.y; if (bottom < 0) bottom = 0; if (py > (unsigned)bottom) py = bottom; /* * Originally I strived to do this the "right" way by calling * nfct_is_set(ct, ATTR_ORIG_COUNGERS) to determine if * counters were enabled. BUT, if counters are not enabled, * nfct_get_attr() returns NULL, so this test is just as * valid. * * Conversely checking is_set and then get_attr() inside our * callback is twice the calls per-state if they are enabled, * for no additional benefit. */ if (flags.counters && stable.size() > 0 && stable[0]->bytes == 0) { prompt = "Counters requested, but not enabled in the"; prompt += " kernel!"; flags.counters = 0; if (flags.single) cerr << prompt << endl; else c_warn(mainwin, prompt, flags); } // Sort our table sort_table(sortby, flags.lookup, sort_factor, stable, sorting); /* * From here on out 'max' is no longer "the maximum size of * this field throughout the table", but is instead the actual * size to print each field. * * BTW, we do "get_size" again here incase the window changed * while we were off parsing and sorting data. */ determine_format(mainwin, max, ssize, format, flags); /* * Now we print out the table in whichever format we're * configured for */ print_table(stable, flags, format, sorting, filters, counts, ssize, max, mainwin, curr_state); // Exit if we're only supposed to run once if (flags.single) exit(0); // Otherwise refresh the curses display if (flags.noscroll) { refresh(); } else { prefresh(mainwin, py, px, 0, 0, ssize.y-1, ssize.x-1); } //check for key presses for one second //or whatever the user said selecttimeout.tv_sec = rate; selecttimeout.tv_usec = 0; // I don't care about fractions of seconds. I don't want them. FD_ZERO(&readfd); FD_SET(0, &readfd); select(1,&readfd, NULL, NULL, &selecttimeout); if (FD_ISSET(0, &readfd)) { tmpint = wgetch(mainwin); switch (tmpint) { // This is ^L case 12: handle_resize(mainwin, flags, ssize); break; /* * This is at the top because the rest are in * order of longopts, and q isn't in longopts */ case 'q': goto out; break; /* * General option toggles */ case 'c': /* * we only want to pay attention to this * command if colors are available */ if (has_colors()) flags.nocolor = !flags.nocolor; break; case 'C': flags.counters = !flags.counters; if (sortby >= SORT_BYTES) sortby = SORT_BYTES-1; break; case 'h': interactive_help(sorting, flags, filters); break; case 'i': flags.filter_inv = !flags.filter_inv; break; case 'l': flags.lookup = !flags.lookup; /* * If we just turned on lookup, also turn on filtering DNS states. * They can turn it off if they want, but generally this is the safer * approach. */ if (flags.lookup) { flags.skipdns = true; } break; case 'm': flags.tag_truncate = !flags.tag_truncate; break; case 'o': flags.staticsize = !flags.staticsize; break; case 'L': flags.skipdns = !flags.skipdns; break; case 'f': flags.skiplb = !flags.skiplb; break; case 'p': switch_scroll(flags, mainwin); break; case 'r': sort_factor = -sort_factor; break; case 'b': if (sortby < SORT_MAX) { sortby++; if (!flags.counters && sortby >= SORT_BYTES) sortby = 0; } else { sortby = 0; } break; case 'B': if (sortby > 0) { sortby--; } else { if (flags.counters) sortby=SORT_MAX; else sortby=SORT_BYTES-1; } break; case 't': flags.totals = !flags.totals; break; /* * Update-filters */ case 'd': prompt = "New Destination Filter? (leave blank"; prompt += " for none): "; get_input(mainwin, tmpstring, prompt, flags); if (tmpstring == "") { flags.filter_dst = false; filters.dst = in6addr_any; } else { if (!check_ip(tmpstring.c_str(), &filters.dst, &filters.dstfam, &filters.dstnet, &filters.has_dstnet)) { prompt = "Invalid IP,"; prompt += " ignoring!"; c_warn(mainwin, prompt, flags); } else { flags.filter_dst = true; } } break; case 'D': prompt = "New dstpt filter? (leave blank for"; prompt += " none): "; get_input(mainwin, tmpstring, prompt, flags); if (tmpstring == "") { flags.filter_dstpt = false; filters.dstpt = 0; } else { flags.filter_dstpt = true; filters.dstpt = atoi(tmpstring.c_str()); } wmove(mainwin, 0, 0); wclrtoeol(mainwin); break; case 'R': prompt = "Rate: "; get_input(mainwin, tmpstring, prompt, flags); if (tmpstring != "") { int i = atoi(tmpstring.c_str()); if (i < 1) { prompt = "Invalid rate,"; prompt += " ignoring!"; c_warn(mainwin, prompt, flags); } else { rate = i; } } break; case 's': prompt = "New src filter? (leave blank for"; prompt += " none): "; get_input(mainwin, tmpstring, prompt, flags); if (tmpstring == "") { flags.filter_src = false; filters.src = in6addr_any; } else { if (!check_ip(tmpstring.c_str(), &filters.src, &filters.srcfam, &filters.srcnet, &filters.has_srcnet)) { prompt = "Invalid IP,"; prompt += " ignoring!"; c_warn(mainwin, prompt, flags); } else { flags.filter_src = true; } } wmove(mainwin, 0, 0); wclrtoeol(mainwin); break; case 'S': prompt = "New srcpt filter? (leave blank for"; prompt += " none): "; get_input(mainwin, tmpstring, prompt, flags); if (tmpstring == "") { flags.filter_srcpt = false; filters.srcpt = 0; } else { flags.filter_srcpt = true; filters.srcpt = atoi(tmpstring.c_str()); } wmove(mainwin, 0, 0); wclrtoeol(mainwin); break; case 'x': delete_state(mainwin, stable[curr_state], flags); break; /* * Window navigation */ case KEY_DOWN: case 'j': if (flags.noscroll) break; /* * GENERAL NOTE: * py is the top of the window, * ssize.y is the height of the window, * so py+ssize.y is the bottom of the window. * * BOTTOM OF SCROLLING: * Since stable.size()+hdrs+1 is * the bottom of the text we've written, if * py+ssize.y == stable.size()+hdrs+1 * then the bottom of the screen as at the * bottom of the text, no more scrolling. * * However, we only want to scroll the page * when the cursor is at the bottom, i.e. * when curr_state+4 == py+ssize.y */ /* * If we have room to scroll down AND if cur is * at the bottom of a page scroll down. */ if ((py + ssize.y <= stable.size() + hdrs + 1) && (curr_state + 4 == py + ssize.y)) py++; /* * As long as the cursor isn't at the end, * move it down one. */ if (curr_state < stable.size() - 1) curr_state++; prefresh(mainwin, py, px, 0, 0, ssize.y - 1, ssize.x - 1); break; case KEY_UP: case 'k': if (flags.noscroll) break; /* * This one is tricky. * * First thing we need to know is when the cursor * is at the top of the page. This is simply when * curr_state+hdrs+1 cursor location), is * exactly one more than the top of the window * (py), * i.e. when curr_state+hdrs+1 == py+1. * * PAGE SCROLLING: * IF we're not page-scrolled all the way up * (i.e. py > 0) * AND the cursor is at the top of the page * OR the cursor is at the top of the list, * AND we're not yet at the top (showing * the headers). * THEN we scroll up. * * CURSOR SCROLLING: * Unlike KEY_DOWN, we don't break just because * the cursor can't move anymore - on the way * ip we may still have page-scrolling to do. So * test to make sure we're not at state 0, and * if so, we scroll up. */ /* * Basically: * IF the cursor bumps the top of the screen * OR we need to scroll up for headers */ if ((py > 0 && (curr_state + hdrs + 1) == (py + 1)) || (curr_state == 0 && py > 0)) py--; if (curr_state > 0) curr_state--; prefresh(mainwin, py, px, 0, 0, ssize.y - 1, ssize.x - 1); break; // 4 is ^d case 4: case KEY_NPAGE: case KEY_SNEXT: if (flags.noscroll) break; /* * If the screen is bigger than the text, * and the cursor is at the bottom, ignore. */ if (stable.size() + hdrs + 1 < ssize.y && curr_state == stable.size()) break; /* * Otherwise, if the bottom of the screen * (current position + screen size * == py + ssize.y) * were to go down one screen (thus: * py + ssize.y*2), * and that is bigger than the whole pad, just * go to the bottom. * * Otherwise, go down a screen size. */ if (py + ssize.y * 2 > stable.size() + hdrs + 1) { py = stable.size() + hdrs + 1 - ssize.y; } else { py += ssize.y; } /* * For the cursor, we try to move it down one * screen as well, but if that's too far, * we bring it up to the largest number it can * be. */ curr_state += ssize.y; if (curr_state > stable.size()) { curr_state = stable.size(); } prefresh(mainwin, py, px, 0, 0, ssize.y - 1, ssize.x - 1); break; // 21 is ^u case 21: case KEY_PPAGE: case KEY_SPREVIOUS: if (flags.noscroll) break; /* * If we're at the top, ignore */ if (py == 0 && curr_state == 0) break; /* * Otherwise if we're less than a page from the * top, go to the top, else go up a page. */ if (py < ssize.y) { py = 0; } else { py -= ssize.y; } /* * We bring the cursor up a page too, unless * that's too far. */ if (curr_state < ssize.y) { curr_state = 0; } else { curr_state -= ssize.y; } prefresh(mainwin, py, px, 0, 0, ssize.y - 1, ssize.x - 1); break; case KEY_HOME: if (flags.noscroll) break; px = py = curr_state = 0; prefresh(mainwin, py, px, 0, 0, ssize.y - 1, ssize.x - 1); break; case KEY_END: if (flags.noscroll) break; py = stable.size() + hdrs + 1 - ssize.y; if (py < 0) py = 0; curr_state = stable.size(); prefresh(mainwin, py, px, 0, 0, ssize.y - 1, ssize.x - 1); break; } } /* * If we got a sigwinch, we need to redraw */ if (need_resize) { handle_resize(mainwin, flags, ssize); need_resize = false; } } // end while(1) out: clear_table(stable); /* * The user has broken out of the loop, take down the curses */ end_curses(); // And we're done return(0); } // end main iptstate-2.3.0/iptstate.spec000066400000000000000000000020651521561511100160630ustar00rootroot00000000000000%define name iptstate %define version 2.3.0 %define release 1 Name: %{name} Summary: Display IP Tables state table information in a "top"-like interface Version: %{version} Release: %{release} Group: Monitoring License: zlib License Source: http://www.phildev.net/iptstate/%{name}-%{version}.tar.gz URL: http://www.phildev.net/iptstate/ BuildRoot: %{_tmppath}/%{name}-buildroot BuildRequires: libncurses.so.5 libnetfilter_conntrack.so.1 %description IP Tables State (iptstate) was originally written to impliment the "state top" feature of IP Filter. "State top" displays the states held by your stateful firewall in a "top"-like manner. Since IP Tables doesn't have a built in way to easily display this information even once, an option was added to just display the state table once and exit. %prep rm -rf $RPM_BUILD_ROOT %setup %build make %install make install PREFIX=$RPM_BUILD_ROOT/usr %clean rm -rf $RPM_BUILD_ROOT %files %defattr(755, root, bin, 755) /usr/sbin/%{name} /usr/share/man/man8/%{name}.8* %doc README BUGS Changelog LICENSE CONTRIB WISHLIST iptstate-2.3.0/memleak.md000066400000000000000000000102051521561511100153020ustar00rootroot00000000000000# 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: ```text Date: Mon, 28 Oct 2002 00:47:29 -0800 From: Steven Augart To: Brian Nelson Cc: Phil Dibowitz 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. iptstate-2.3.0/memuse.out000066400000000000000000061602441521561511100154100ustar00rootroot00000000000000shred_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 iptstate-2.3.0/screenshots/000077500000000000000000000000001521561511100157075ustar00rootroot00000000000000iptstate-2.3.0/screenshots/iptstate-2.0-filter-ss.png000066400000000000000000000135561521561511100224670ustar00rootroot00000000000000PNG  IHDR4NW pHYsaa?itIME 7 - IDATx]F$N-T rS!9H\|."@ enٓŴ~\v/IOUu6qxd22Nieӟiel6ft٤ilvL&Ym$IbNwww*Ied2n6:%$#ߠGHFsHpvlB2Q-R4vUO1x44o͋-ruGv?7ͻIObJ}=wَ+BQ1`}bx=zBNi?g/BVՇ~p[37M$_|ఇ҉02l:{,6~$C =Os7y }2l⏙euL*5dfyˋ9i3y f&D=u[ԚNs$|4SuK_ԌMoyTJnKgcNs3C@pbBCSNݖj߭ǜ/Nz 81V&f}'8Tѽf gٻ0yo8𶉏?xs'h;o9$:=g˭, ]oUz|yˡOaWuw{l;ș`w9bэ/* ;R|q"7ZϣZl?]C]/-upSYFm|Z N .AJs.$8݇"f>Ź~G>T7~|W2:w-Q)}qa ݾ =VQiuKVGGeۂ*͋x6cŰ<{ gZ<+ސu{ ޣ?vϨğ"{xGGqc g[1,/_Qzaʏ\^7_{O.㋣y˺q5{ћ_&2'/?;Wk.u5,[2ju\W}nZub]u6(kGjoU=~̚ӧ427ٷFKdZ|/Ez[pőnkAC}|cjyҹ4YƵ#,—psZ.7& faP ] (@]ebW{5%>BY!܇W䴷1svZ%@;^p:r}l{~a޺;Apӿ`OJtiA1; n]Ok0[^5Ͻ'U W@8i9/r2*:A&Іu?pEPy.|UrΑ) LnڿMq/%tؽ_ZUYO:nMMeXV}a]7 h8NvU&C5L۲ܻݴKm'hUr4eէ|.W@{I'^7Gbzol6‹o;̏l޽{wwwvlB"ooo߽{Z6M`)C愿C%I2FP,jZϟ?_V_}UzJ4-^ :dNf_O?]>b͛zL&?/zX,Bˆs.0v$Ii_ޗj|h5oLõ4) -u 'y`+^B/<Pe~Z?Rܸ4(OF[|y m}( ML<[ +eQwww^! OÇwwwiކh_&IvN!ԅ/1/K.z~:/o$~ȊobeYȫPW՟G6d{ｗG<n)ʷt/UnzRUb^۷o$yGBl/f3ϯ|`HbIENDB`iptstate-2.3.0/screenshots/iptstate-2.0-help-ss.png000066400000000000000000000245031521561511100221240ustar00rootroot00000000000000PNG  IHDR4NW pHYsaa?itIME  9cG IDATxK9݇>} A 4 bXϞwaŊ V@H $}Œ_e|(\Wm0 ڶ?o6in~n_|r\׫8vn뺮Wnz:|VSWK6M#Smrt]'!iV T/^""OOO"Y\.̮޾}^xիO>իWz^vgs(Nf@A;xYEG%yp݊^.qpو"$N>5Qw޽^y^E-ɞ|^eEEVEG/ٳgo޼9?Gm|Cu"om|8DUn7oǗ/_~Zmϟv;Q ]׽^emr</y:Ql+cL}OOO=_hXE{>E}72~hm8_6jne;.4p8(?OOO}ŋo޼yh.NFVAM/kHP|'+%\dLW抺:o!lݞN'ٳgmv JU>(N|FjB*HϟN~7ߟgQuG)j$SZ,dgHW}n?_~J&Aj~Q8 N8 N8F.?~%ؽKeXa= N No\wK)rFʹ3d}B433N]ī'm?׏ϬV0j>wW%(L]րi `to6T>q;@hFئUgzFXqRG/-d 9Q%va4O)*H#0GF^'Gt_P&Bur 1A_2珺 Bxk%l23x8adOrLEB[jyOChli ESS'8Q 0-qj"'7L-"'' ' ' ' q/Q2]4m7+!MǯܽWq"'(Dc񑓱6SAiv)?EF47Ҏ HV-K8a(@dgnF6qA [sK;HOSzX)a4eBwg @v'P˜%,NI 5):`e)oM,z顉 34)ɧAmZSbDN11@! ̧v1A%|w'r(@J<4R)%V`y NJ"X8W/4!tˍRpXoB9ڶUF8YM'=M"skdt_Aqgj3x`lLПme@ ArZ iGG_g,IzFNj 3*_s"w`46DKư괐L MH`\1Sj/`s8MA4_pVAUh 7?kVq> bv$c+0,5[q"'@z\`r]JhI^9쫓U-*̈,eWIS A@Q2e> @ P_mlѭ{-KY-gGTcڒ{:L7:ܾ|տ:v#oTRƴӘ%hj0JjJT9{yM5][=d!&&(ʤ7N|3hi Yu2 Zy3}rTZ'[Ɍo{44(QFeL)U97QL%r2vm 5­VF[>Mut-BRWy/L;_.}6[iJO9'ܾ'U `]J8 :/dz.,sNFr- "G2 :%rcOD6 ((ݳ>mrJ9ӑOr`=<{iЄ?Fَ6V=?58α*SvXO:5Œ%&(=tRbmo8ԡưNYOoXAg44*qw,VlqCL^rqwqmj1VFpbjCm9q\9@MZp'7mc}Qs^&m7 rkL+W>wG'& J,g:q&[f(_DNv.%W;"WYր`Ԅ%'#aXo!@䔭Mq̃.o ȍ>ۤrkWD`+t#6vfrO)gIk 10vvP;3<؊ DZ40[;*QJ>_4p񳻕j8'V}C%0:dfC89UR)%8ȧvԚ#T{D$lELJ Kp`r N8(N˳_d_[8GJ8G/R-m[mx} vW}$az9nm߁g} /n/ FAkz?Ӽ lrmң!cdqD䰨Wahߴ];2]0UϟݞAl̄N#;ƙ3S{mQ/7zF5I~goaB2XN}Nڸ) 99d,`жF @,HfzF>g"C,ۍX2 0F[9Wݖ6SbBPƦsglUڟsGN ƥqꀌgavRڍl-3L2}Ki|֒3>sD&q_rJ;o%Ҝ D!P15,"1M"'"'\`r]JI_<2cm09qj*Z'm,ä07ZDNvݘp3m U&olPEj0Izwnq7v)qVFl|`^<)0eyWn!CƔya62&Ĉ8鬸3 OL N9߈:]iw-8}޲X=H]0 zS5x*p%Mwx 4p`mt409q*!Bkbs[LbĩLXJݜ{./eS`}}J,qD }[v 2y>>V*ԤBm]ʳ6FqRחJ Iٜ<!ۊ3#XSg^"+zb N fღE+RV]Fa=wk3 O.fgU IimmZ7xyc4)<Ǚ,tP{jUeR p={wLY#5~KO*KOG@q@q@q@q@'@'@'@R7xrn7T-X01oo~;@i^YA`Eܽl eh6R$S ´ˍg.7vDMJKaPWbSΊ*mwt`]ԧ_pG"~o͛|UH?& lrā8P`!B݄;خ*ٹiC28DENA -'Z`SZ*׮՜}YWYÀ\;tfP-S/i,JU6 py,y?' ȍMӳlI9^Lv1Jzٽ!s=ow6)b-z(-%sJ_ˆ/Cĩx+~O{g(jŜhT֛7lݯ3O ȗZUXuԶm6߮{0ЂvA>NJ;bY-Иy[|b`3e+2]uѥWqB&E&q}Ldq%1k sP|XOxC}J|`@TJ J>VA rn#+ySݕ<(K3=r S k9ɕ6Մ+R]ɣk#9ڤg!p%Yg`UJ^r\'%؟ N\ɗJ6>U]Kr0•|ī)+DN|<2J_:)Ugg`pp%ͧFoL0~ @_`Hzp%13qҜ~))"Fʏx9iFsyS= fДJ rAsz- mnW>ɭTލG1hY D:Gi, F9- ~irW %Zjw[xvS0( 3E.ԕ\\_͖k[e2Ӷj=9qಫn+y2G~הMgDgv;K["iww>h#,^\ JOk.MEK:M_":0z>'5Yu^䉎5ZշOL< 'Ib^>`@ T˒YY ԡ&rSf^9}~ ;+z n?O/Q)fM-K}<lXPO֣P>'JO&r=h..K6coOvGۺ'\SpΩm[9`M|KTNM앜h\k+-||Й5xG 鸒p^tيUw@+y1ڙ"*cٟ犇ʮ]5VS-H{S\ɵ=(@wYjJkȵRѱ1-,d@!aEuwl'Rؼ. }|DbIaaR,=((N]! }%,&[sBH3Jfkĩx;;#W#{E&enn,>jn DCVG Wr׼ٛ-nim۩V Am&L,^zeF>A  Fjv$Y+-ygn8@Z[W JJ́f 2<5Y" .=g_e7n"wIٖ"Lh,<ʢO%ޝ1DLyԤaPrZ/ZsL3-1MhSsbtJř[|mw7EqF>uشF b|@C&r litIqtDOtiXz!EP&WXAAl,|XhnvN DM;-`rB\Ÿ9:iqX\, )i0d1\`yۢU9ЕH9@n+\B7oH_ƔϞq{s,~U19';)w `sP6rj61@K&+܊&JKG3MZ7N5`Zˍe},Es~zLy^UiGP5#oW֣Jޘ#,}o/w%:3V%r9ȒMs,y~}21 rE Uq5y{%<3f2aT} IoJ\J^W8xqgZꪕ=g=DtyOo)Zߕ8{T{Tj^hkJoD=g)ѤZS৬e/^-S%8N*.@XpQhA`3W9qmqU{8hpg<=kqv#1S1B{0rpm^ha.dLjº`+q%#b7/DN#'9䘟+[lq N:ʮ֛+yМry5(ZO!J{v*rOtskc^WλABS޽>m لkqݩ:MSx V}J^rVwjeЌ=W֕X) >1`lDP_#lɁ80Db5Dލ),+ rm?ҦR^+k2ͱm1>E+9gGT[˒%-%]^j[ط֫&ۉdF|֦9j{ ڨtvTr{f)8`yw|Ɗ,! q=̆qMIWr7%L''YD?wS=:x8gbfum}]량d3۔d[=m`l Ad^sO?LveRIDAT87V|u՛e` IWP͏fsyS=G"<}\k͖ZKYJXQCJx0"l0&w*E_r$hFA[3f\Bĩ 嶲7(c۲d[fЅqAgjew(Lw-)1sYU",cXbiйD> )I`rlXo ;h$3+֓ 2$aXo!6(A;+y3dDԤ P/J'՘}(>We-riWԣT#'O柦Jބ9s4 $̕&Rɺ[!Ӕ\@/=䘟8 !H&^N`@4KP/#n= S_FVX8 )jvDW-l%7r,ޛ'NaDq};@bȾ"7 0M sj6 AW+Q&XKdM-9s/$^&xϬvlbF{/H68lm*朢(8V9|"#ӉFS|='[O[qEXi@L xxf?f չܖϞ$j%|EvWrۯi:?ߪ}j)^ R9WGղTrTFc@ HƂO]G+yqVI㈓ԧzƦm<꼥i ]_Y`j=!K߄[B6<_ٞ+7['f( FNy%$΄{Ov)vy ;GkT/F-B`j[A'Em+5M#WIL:SbZ=țMt]n{zzO~_*_צi޽{ۧx\D"A!mzG_}xl6|>w]w\l6믿>x<~Avwwwwwufu]u*D rZZ*jԫr^M\%|>˪G.x3ӓ8uݝ(n't]n۶\.gF~ ǩRS *]~εO{۶|>9T?Su~o<_+6^Y4YLQ Yjε#*V{vŋ>|O?=<<8N?޿_|g?o?ot:].~\Nׯp^wwwq~zz|^7ͫW>S4E1_m{<Wt:?ىEE~'$zj^#⛰l["7o4Mnl6lp8-vo$yS)9RqڜZkkZ꯶RKMJ̈́,/mP,q/QRuD˃TVTc2Ym*i}%Ɋt*!4QwiBw]ֹ!a  vϞ=ضg>|ݻ='.oo믿)mvٜNtwwŋv+|"?ǣ(Hjw]'z~˗/ûw6x4hN|kOۓ[ϩQIENDB`iptstate-2.3.0/screenshots/iptstate-2.0-lookup-ss.png000066400000000000000000000243451521561511100225110ustar00rootroot00000000000000PNG  IHDR4NW pHYsaa?itIME 6  IDATxK$7]5LH(l"Bb ;! ,,vD,H(ff9sz wחrGQt|)_ej f4M_?x4lfnfs:t:Y)4|ffsݻv{ssSUĦ:&mR1W  lMیt:lT罼rɏd-n3UUO|?Oɓ'Moxwwv{^4͛7?Oo_>ɘRʘI?v<?ٳ^я~??}_~ww_|>GϞ=;UU|wׯ߽{gK[Ö 1=vm=J.nWUtvWjϥ$=r7 ۮ:K2'q^_7_G\aݹ҉.,Md}tqMut )n6{wwѣo}[O>}~{=zȸҾ{=f!lO;eڔi=S'Kb(,# i .sjgΑ:Ѻ1C$0{9AdGws؏׏:M sYή2;Ţྙ?,0A|g;^\/$vf]ȼgE~M8lߙLwn\zg8%!\YNRag›PO|f5k'm3U{{ =$YGy^C՝.vfpEz 紆tcCDan>}ѧt|΃)g*SGsg:nfS90D_X%?$Y-1ÂUvn{hbs^c 5Oz򢻼n):g]~tY~噟as__:1z_lX)3l.\[FX)*vIu\w-::?Y *:w[2fwI;3?y C]댚;u<2 ZPqѧf(58ղ岶0U紜:c\-ߒRS3%hgڊ\ kaAcZPmz5ص[c.͍=13HQ8vUf<#o_?;4e=;6t].Ugrg[H5NŌ={ D1 5ɜUl|r/vK9΄Hz촨v-}zw/3Y÷?;->l/7J6*`gYwݐ-{P>w-x݃BMͫ-o?򺸯?iFKqvCͭ¾0̉9@q1> !y m>F0لHy\.s,Vz+ Y%Xt󀰎/嬹[ˋžaY]Tw^̚^^_vr#*(8>䴙*C,/3k ;&Ipjw.zX~"-l!GhYײ3&@ނ]ifwm(y)|}Vf#*9U$_g^!ViKc3L;ll֘9e1NY|דv_M'l=3CU;uz7jcK+猓,w, v-_T*/-$N sZ) p ;4C͙29@Ini9@vij+7nu_ ]@g΃[W,X= ^ v=^_Wo޼iWYcF*)>~=% l,8-No(X+,_rjARXWUzҷgL3-.mڌ%SXGM= H^z6{5Y&!W{Y AMJVӹb_вRfȃ" nq.z]:x0 Rn 54- SxΫYK=ԑ~J}={oaVZDRؚ=[})j SڤO'fIBklˤz(W @c ꫱6$WK*.IEw|L X5!a!ɒ~G{WY SYk咩"k9-.; IK5Jz(,6]հPqȓM{TƬ} P@8,9fQJ\}(` F2h=P_1g-;Moވiq1wJ2mVP/+}4S8~\Ҟ;,Si!d :r^T;,ÎʵOxQb9zfo~a\XijKftTJ\ϲ^UTDn |{=&}R/FջՂq^]ΰ\)h jIJG<yrUrtΏ|B MKGY^qd y>\ ,)_y+O׹J>1zwG.V?L*7[g?aBkZ Gw}߫RTɝȎYNׯ+I+**Lx2T^FgT {UڟN˛/JS}1*ndz&և2_yz~.Ed2vUd)rI6(Cܩ|{'^jI30Sͼ3'JG#eìnAQ%rԖqӥGnIyjb뫭gUvP1=da:j^aۈNJVJ|cJqKHS_^~\sN@y';*PJ.3̞z|-iY / g)ƖJi bUrzUrqi"XS1Ⲣ=F$Իak"䂅tQ%V\R%S3B|yϙgQ%O:٘*sQK=BBh}6 hy*yqB˃z_&!38Dh,y%ԥ_l6tUl+oJ ea *zq*Yۦ|*L_ >R-=‹o5˖t}&4զ%"D9SNH hԀh*֩m)Fwy UyMR >Ur磬TqtP9Y HkwXx'Q%W+P%OD `*1pNsp9'T8P%֞/-<#ty>Q%YUrITXSJyt@E?NqqPJ^*ϲ^=,0%kb.煜>TӶ9j@^븪}&J5Ζj+=J6[UЉ^me՜BF#!Z"X ,vKrQ*NUrTɽ1ZU`V.L>,-:E^+Bܲ45jJn(C<L;(z0^MJS%7Jdx&J_{ Fe'3y /2ZPn䨒zFUr֯Sj" WuX,k8KO=Ÿ%T>J9\ Aɳgz. f#qW%}$&RQ@)7ag6kTOeZ UH%?E/ߧ.Tucmʧ0uN:1՜U{:TS%7J^ &SI'?N 9UW%ND;j"/zu;z/ZZP&ՊtJ&ܨg#*?eЛѡc8t.${kÔ+τt3Z4c"wәGo4&dk=JS%lCs,{iR{q4C] {ڋ8*9JOG*b,3W A/Mgs凡SAF5#C]jo5L|iJU * ~S,!3ɕ{ D;` r2bC#U UrI'(3Wj݋U(_ *TQ%`*+(Ln@ڱ3C$ Ur(ٲljU [=qţ%/H=cyv1lP%W'ljocwԱH S# 4SFr. 홴P++QK*U At\'[)/D\q%7lΔ$'1qjR3J>FCОZ?:ɜgU*ŷؚ:ŠG Ժ9ؤ| *yq !@?sH-_HҮY=I>ٹK?ӵOy<:EZ`! 5H-]tNl1P:{0mJޱܑ N}l,O6?O0Et*}7ǯ`9F>!Œz P%O8|䆷Z˭T3gP%$ ?Z7د׳Z2 m\]Ѳo%[Z^О .k%rIv䷼}`% 7IW}a+yY ,fC! pN*9G*hB z4R[|w%FXVJ܂ &+K,UrxZ\+m*OaufrT5gT1eu:#h1$eztqzį"^B|=kU^IZcTɕ:\xIDAT1lu/5bIzuM=Ж%;'(pNs9 8' pN8'9 ̜pN0;XfN̜ z 8'pNsipNss@9`v̜pNs9 8' J`s pN8'9LM48'( @0 zss0sfN8'fN8'9;'(9@s@8fN8',3'pNs9 s pN8'9`g0s9 8'&eipN 0s9 8' pN8'9s9 8'pNs9s pN8'9Qs9 8'h̜pNs9 8' pN8'9"hvU, b,3 ʢi0sqN tR@i="Xx_d?}l6m >wVUtl6fWoxl6UUmۦi9n˗/?\777nvlׯ߽{p8}իW/^0?l6|VUl2n._ !moe۟Lm$oc0Wڇm+SNL|>7MNS\<66wޙN۷oN )pS8oSDUUG1S槦ip/h1u< u:)_O?=>?~H?X!Ǧi>_߿|_|cl[HۭhkC5Fޚc 5Bsnɓpz~ol淿/,gI8UUxlś[Դ%uc֝ Nm6Sd_;_m[j\hf#l*׷Bј݄E.SDm{nu ߌEsx<>|ݻwx/x>7quglfbǏ?ooo/WUu{{xnMӘ2ww??t7E{ﵞ=mm!Ek!~;cN[$vmlsn͛޼y#Ft:v͍_]IENDB`iptstate-2.3.0/screenshots/iptstate-ss-filter.png000066400000000000000000001576471521561511100222040ustar00rootroot00000000000000PNG  IHDR4nX pHYsaa?itIME)#y IDATxy$Wu'|o/k閺իAI2Blc#ـ%#0 d1K3`jZnzr3-73*;*ލ{ɡڭڭRjoaFa?.8u\Tӑ%(>">O }MHkulW/z i3u-a%}YH: YlW&dٮBHZ^>"Ϻi.BZ| !e] -4MeYx>|泟jM|ֻ#U]ylӑuB iՏ"d9GV1d#,d b␰<+UY BBt#,ՅRiZvi=X98STCoEt77,'Wz?zwދN;v?~ۭ.xb' Yǁpm-i}Cj(nַ}#_~S9ZRq>ql4cpzͫ_> <替/{=O>伺x08 N?F Nrc=f,+8!cb4 3v~ﺫ'>ɏcsޭgz/Vpzo׽u]]Dc>_  9__B.w_Ք#9?'ztO41>>~cGGFG_/?_xy׼8ox<>33+;֡|>_~חo7WKӍ7} ž[n7:ßg yk_{NWW?>=c}3o<7>WW===w<{fx/Doڰ!< tgr7C28=|_}GU;6mlOKWz^uV%عs󎷼;q;Zo[Sm?q}Qr7~LRoO}S'N?J?mo?}鎎w~+_\veRѱ1Ɲo}__>}z֭G˕O~<]~/wO#Hۭ'!Z@ĘƁg[lpzzx!wpk}mtt2:2o|O?&&&!r[yᦛn0=ouJWZ(}tM@oƟgysccR}_* yӄӧO _-oqK&//o}[?Ϲ_ov7 !T곟Μ9z]?O'FGGX,>=7{S#wnn&zMΈqθ[htd̙L3N ٙU˲\?[Ӈscc{~|o/58wlqlؚ7nx)w&Nto޼{z!Dk* [ouԤʽ)gRx<8 CC9Ǐ?~ؖ-[?M?8Crb':Ze1^zd_zmpj:8E7 )bu n%BaJkq87۶p4uW[0d}&X?}oPw&B(ZHoܸR>7HL !\okH)}ޖgݴiep[/v5qѭGV[v뽘+&ixE_wU?8p/}՝: _Dw|/|#85q'BzJlٲկzսܣw#gnڸ|7u8zmp0. ~%.7i]sZ D&dYmENw2̏~cGrOz 7+_o?x OԸrzȑ@ w+&oyW5wm@G3Yos˱8tǓyOr:y׿z2#?8hZV#~<ORj[NmpZr2 WEg2k_9Z]D#<3[?c|rՖf CC|+c|?hӋ _|R[/n&ɏ<668NGw+_ #ˍ?={Ci,E|oS:1''NX$kxܹ͛7l+4"(cq11fGn68cUÇ>| Nsϼ^ʋ N'68ڭ}4]8ozK݁qg-s3(Q'DO: 6(#w{>nw YTB{v!+ɢrSr.!ozӛ`)9+)uG!d>9<B0b$mۭڭڭڭڭڭڭڭڭڭڭڭڭڭڭڭڭڭڭݞFڷ^"C}42 ,2_ſ n+jmy#B4oZkWWrsxڭ.~[nnnm˩mXliZϾkufej68[emCt| }=/­kvkSMUTHProj4]Ekm4j68[UE0/,"˱HVtE/ڭ N!F˲\~1MSkm6~F Mۡ|,O*pbr^o/Нgw6ΰiBZ/sgnߍfF#p+O$5m$%MDZ\{[־K)I)~R8qƑ[n%BnTj9x<|>JiP(RJ6 ڶwR+8N$~ rlf>m0 JG".۶b6JEJIiSjyjڤǗlfY!T*rNmޞ+ymۋY/sm^9kȪzV7 ڹ:naJl6եj6 !jR>l6 -*RLta )DDD;9rJp8D`TVbiamr2qӪ]ΣR^4ͦl*FUk҈M֒y{6Y< BnMEvB=oZj,YO+o$SJcRBҶL&bqXfP*RTTbF 9c !,|bqffƶm@$ !DOOφ <O&d2bQk-mq)%μ N»8.p "Ӹvy_Є^kWJ!&1Lzaz+if-y\Zw,ba3~+έ2i->'Nhи? !7m{ƍ|>ˡT,Rʲ,۶+ YcGbP(dd>^Wp2d24R1ǃ(\V*n2Bzm}-ed9MV=5އ52Wd5MY}q-FJ %1if21lEAu)lB h$1 # d2)D?URa۶x,_.-b=,Z_jmK{HCaI)  97 #L={Z[/E,4hHB'8Zk)e( Jq)s'O 6a?x~FBWxhlݺ5GQ1=n|||tt nhld0 NhT d29557t;uԳ>r\TNs<SJ|\& d2933WZT.8R^Κb"s]|;qy9cM2^m9%ՄÆGժr.qy$ B>/!)gϞD"BT*5==]T8Fr .v-2 Os\WWȑ\x:qO:Eٹs'T*e&& R0٬2n޼9 @.K$߳m)|ޡкfrtmr˼ˡQ-_7z+D̋XgK htsqX+WEIYMnwB`B=neNk]4Wⓔ1^{"WB3B)0D۶9h4l6d87n BXLJy1-[`~jRڎsЃ"J' Jq͛Ç_JRx<8ιs2*X[)N4MӌD"HrȠ]~VX:sqex9uaؖV[靟/XOky 즬;XU \j7jӥLлE5Dwr5:W+ESZ6!S Aŭbqh^oF፟&"xRfsc y[b3gx^#~? b12t:m6!}kă J)Lf===&ZVjõ/RͿQtޕt5,p{}J2::zcH>ovvafzzX,"ɭ(Vs!\.WU)e8޾}{.O&[lbDb||Jӧ`oo/c̙3d2 uuuYE) ~_JL&qaov0E2%Uk9]hn<8B-Zl9%tbw]+BF xϑ&IKX @k9uiTT!Nd2 V+ZUb1 j7lP('''Ѩrdd$! 3Ɔd*PK1:11Q(8x< QJSTZMӉD)xu|q_,b.jS6KukO"#S_nIhiU M"4J9)%Gc{ٱc\oٲEJY(Ν;nN&R` |DBZXOAd.?~X,|EK&1_.gggƍ ӡ!#G͛7m ||ZiI[/,YRˤ8\5cλ5@M:Rjw4EH3YK_;6X * H7o4\|++jni]sg0 |Z qc 0M\.cpT+J'N@Ny.T*AH$% ,K)l:bq4ܗSn}̙|>9ߴi:^4 ضmr||iTbRT(ud2Hd7oF""Ϝ9S(p`I~גUF 2re^ 3lW kOQ5PJ*J҂ѠeL RE`đH-A%)% 55w:Wa SJBV@(JƘTvD 5 AdM IDATlQBZΣN@cB(kT!40(ؕZJaZJЙj^l685g3q2J#)gO7IJQZJFJ1F)!BB(! Z+]L$fMcTk( B!%Rt$g\UK%JK GΫAp WN# r_$0~0/ q^^_+oqrt yoŵ:00LM"Zp@*D"\ r8R{f٣GJx<|^,;!D<P. h4Nc, n{Q,cHضmۆ N:5:::;;1O6ɄBt: z{{ Zo6lMpӧOb~UZEpR鉉 %B,?ZH&Je.uEE)U"2q)@ 1^,+_,' ( XkJ)R*%vZesFUEF+hxY%@jΊZֲoZ7h"zbjjҶ&@ iz!Jk7P˰(@4-!aT)A !-{ '֚4HeP0$ZXx.JIThF(a H !p(( )cJPJ)1J)Un&h̠8Iɒv輻8.jz54BY6`)jÒVWmq ]r: WSi` -Jh>/ X|RjYV>/JȲzCCCjurrX5ܭ&5 WLJ 2^Sk=22211aYVGG.U*P(T,)7nD"R`0O?S x<]]]x)SSSN^/V@ mHϵ%pIBtT* ÑPTNg3RAAkJXa!4T"-bP8ˏ2g6*H)%Di Z^9k ]֠q}MV҄/*LvzOhV( k%1&RJ(a3bQ( iض~wO7gO72:FlκԜGnp8JiJ@g%VPV\>/ߎh]:&*k'B@ ZFPBՌ ?0J4Z)IP&֠50F5#T)TVȁ֠"-`@-B)J֌1U[Ol^#W5M6żQ|횶)ܲ\.Bp1{^ ={irKf\j*ex6- pՔi;Fj2B D"T* !D bBlqqttttttff&P(D"133V8[*,bՋ+j%tPhҨA6mXԴNFР)g BH%.Q@@*]NHR"=%@JM@]E[\Q+ cLI]d΂tt ]jI\"3pK$4kЄD"if27 y>߱cG("03gR.p PỆu\k>9X K!>ٶNh4D"aL&nݺk.? p8lvPHX`>E N,Aw!Z3*@ds9Rj頢wiZB^OResh eqUuz1R 5h2 '(ѺsCc8EյX}M(ݐKy@3T]CCKנP=UJ@5>J))UP(PRf2iJ*/:*E#@5%ւR֭YJ Pَj*X4RhT4eR`,OD&D! @jJHg~= (%57@(PNL5h^E3!Ec ]r?Ԯt){qun?!}keUR722fSs1ȇ}(06ƭ4C# |>р$T*1?)MOOJ%,Fr4!`P gپ;wvww|jjv*JR0M8utwwcfqZ],ķ%aڋp6^)ʈiQN7d2(=(E xU!rBiJ*xs&tCJJ2(Tx,JB aB(y-ZV6H(mPb&TJmW#TݛRŢRI)ER e2Ɓl6x30 qF%m J+-)BA u"5Ln&B )#5|'=)d۶o G` ᔀVC&RmҲħTyZ 9x- Di-R*R5쵚L0AZy>)hoHG0FA N-ep]J0iZwܩTm )pܰJ h $4zi zi4PXhx+a29DgA&oɰ`_b W˲@8ӹ\q(ֱCA60!Wn:$J#T7333JaWߏB۶;::pHaeԾ#3+*fggR|> k?~zz:@$!|ԃHw~FZ9Һ#EhT}팏K%c+PRh xgK(=95==35h#!-)!@ɩqdQ 5 @<'phj?}( B!@hxƍ\{fffey4!TKHNNM;JC(!a!)\.3F ܰmS-HiX$>?!ǮfrٳZ)BHݲyeR3 ףqD"cǎa7](0 ]]?eY{l@Th,t0J>X<QV٬tB,d 1HضL&rT|8vrrrjj #gHqyX6eZ~<+aB8B8PbF 1J 0,%ZQF)aZiդUVB: -ҚpOh3u;6 2JR  Қ0k]COubShJIgV ZZI4: I9Vs61F Δ :nj@G,e&2 ZJ)(%hdǪpR<&JɁ?aXl떭ŕPZk7b NFD nR==^ǮVq"H8L&cXoooggc pδR{w ==%!V5Cvt8A*I<+ "ãA G)iFG4GA#7[2uER4sZSBZ2 ]yH$sNoOGG\h#d@`.6۶\N&6VU5MP(R) Y Uj+"E!D6 øwƓ!LfÆ 6l333lv``D"qYܪttth񒯸+=E׹ECGc W<3n@=djIcSrsOsO>=/߶E*M)sp`ՄRøAozz6JwtDz9v68©V+^Q ={ @ੳ.8gR-[\: RR !4+eW# Qk`(048CBRRP Loٲc)%J+Ψ:UJ :'?=lPR*N:fB闧u8ۆGk-W>{8߻kGT9zdjWurfݳ0 Z)Sw@Wgq;˶J)|ȵv?sh D*c/'޳{JJA87M'U1N4-DV7-g$>/25=+{ՏMdϺOXTϛ}[ T.F"$zb9X@\.U'Nx^BHP0M3MOO#"6NX;5Dx.NK|;A,eD|>dYCP*"$Ɏ;v` )$ɑ,ORd#LfS3TJđj]w_}fv6/Wy-qnط󧇏\y։R8=]Jjz9N !Al \]مƽ5nֲ[J7]/;[aS955uiBH<|JKk &f獤pLf†YPȾCƄ8.);;;t=v_җ7w7 cff&͢sbbbxxTty hJ%) BD˲VsZ_;w3+R#_5u9F,g)dFvfvsìU6DÁ=WIZ_qJlLg2 e43 \.75=]JԔNoos#iDbZ% ky, PR'mG@:avu P4P2jꙧ 6ҩ}v5Jp8Je8#JjeA`ʥr R* 0N!R(R*$ ;]\h634# ݿW)E ( 4HEO&/ˎ\g2D 拴Tہ=;D2tƻ걺%FFm[( aĢQS :h-]X&>-bX>-Թ /D-R2ͭك!>_[Jl4`,zAo^Q8~Rd"{(Q_!5Z .aX)eWWW,C<;s̶mۆΝ;u(C,D"O=TRz]]] '44b) q~ ؘm|>ϣ\.?TKy=۱񼸰=oJ{j ߶m7] H+EVC"x, ۩ `Æ!F)7m;5^tCX jxJrlipDrÆA[%S"0DkJjK *Q$c) F8Ds&n)R/PFJ!^uұ9i_e2> Lka&bbX" PJe4Op]De~h9S4]Ҋt: @h |2h0 ,Y2Z),0ZlQɤR AtReVU[ DZQyѐ|:JFklk[vE"y]Ԛn=P`~ǎpxxx+199J1R-' ␛iJ){x?O)E4ͫʶ'O^qϟ?sW\Moh0L$r+PbpS]NӘDYB~ (jUu-B^B)83A͛1!JE떓 9u;a  x/l3j ÐJ2y>Fݨ| IߦP#P+U41WBsFK܂J ʈvι#P88g@œK8i1Жiy}> cVp@ [ڶ JAa%4 سR_ą5ykPZNç\@*JsFFt!R J ZQ%ιpD\si Yu.;ԓnqGi7U3Z5 .$ZS'Hv g`U>ٔ׵DY.M!ֲB`F4Öe9;;H$zzzmXB˵su&AFt|E Jbd9sM7isWNMM8q"\uUpرBi&1a%iz{{ML&L{PȲ,)e /n]k[ @Xv[JjA8 |[w !TR-"#d[-(Ηܾf >+5r0 Z17p}֚8B1B4-Gf-]BZj^".*X`BBI3Ǯ߷t5h8cP*D8±iM RD | y*PJ@k5fH)zb*A)F)H)ܸH[ ՜K)%pP/dAKc^R 9~RPFRM0J%t.v'tbvM(c\ixqRZ4H%̄ҪㅊU/'j(ZpI.*Hcפ4̥f<,8ibZQb1\.zQ&D K΁XYMۅViPV7jxB.RP@@krGGG" =ydgg޽{ s=W.62 #"@ 9z===Xsd2^\/Ӵ}{뒤5JX(w^"pz0VeWo{NskaBKtQJo` IDATbuwe}==_ uJ_o,ZVАJڶ}r9F3 }⩧;璉CلԵڀ\{pYh ݍw`b21%Ӯi'>_ ZBXPrcOιHC 1jW@)ΘV @snV*UZcp Z*kI3 @ r6&8 -.VuSy0ɷ@pF,Cfqu q* 1/N:X~|kfמ;ITzR|_M͕jktt!Zu4hPtFHb!$-.Q)d4߼eih$<3L\5e* %#){w"=gRRM(x,icRvP)֖- s͕:wnjjjVV!%#@ B" |>R+UiD)RUUMȁ1|vXk~3,v87ӎ@,ڶuҒ1XVX YwwW!/W*-ctEB B!$ZKJJq RBXlphPKA@SJ}&:Za6o{ & (ZKpHQʥp/5pn(%kjEcN@szs>W-6 o2&;\\ԅU) bT*1ƮJ#Gv8X{vv:Џ(,R!e͠0XdM:= _ꉉ ޽{:d:Ja1@Q*ra! 4J|,Q,_9(qp H !` JR! ۞8?544DUFj{}>t1P (U ؼicR-ʉTF)P lބ7qZ3?Hh8\~ﮫOMO7lXJ*J1 !߳+sg ac9لA0NF&T+E)#4!  в)ҚrCb+)Im/{ &4B6/j$T-ģk4U[_~-\wLZh&wQj56!nH = `!A ݀Șń֞x<fĦ`0Ufzw~B}a/CCCғ'OBo1?[nݻw3gόi˨םץ5\7QD t*K0 FGv&{n7f\)˸(tj(mv&n #E6ۥ‚t] NaaE "#4LH1EFۋX&7ߢ3.R3&^;KWw\l1Eas9;S.=Z y˦i`<6- ifq";۞h0 7"-j㳳Rɶtm4]7'RePEaFE Cq:Pu48mkaz@wG]M]$~]C{OȽpi6Hu?RMBnfkd"۪ꚃfsgȄeJs9w}qq#, R plaxm/A;'|AHy( ? 2$w&z+? U+}?zxa@5~`)BvbF|768 B#6nj"`f?uàUGDf*u u2-0Lw 0ҢAia1Ş4AjuiZ4~$j{3dp[n]MU ,4<:4(-N\tkz墏Sbz_@X떛9?̌m9d2r5.9r/?z( ǀ$ּz->@&0r!"]!/:믿J:_h^xu s9v:xoEݻ!=ybK6jerlK(a$ԋ ŧ%Nht4r9.Qw+5 è.JyDjYtjbb"͔eqwa1]k{`pG;Q8:U()[ZO{`\jAΫ:bZl NauDEahzr`EhutQhRg^{qhӪ 7sKk]6%B(U4eY333B{>| /p~~^ONNB"P033]n1)؟.˲<b喗 ;ZX, ּo4a ,\(l"ix7xt:fff0TAP3 X,0ϛ>eoLQT] -miǏ7,F gi۔+XGw%ÓèE' 0z+Qkw=lJY{UöPTrvqV`#t:X˲'\.] "z뭷ݻرctzyy +gZD~ u]l=d#l6 zzZa|Bj5*$'ph4ǁO(l.,뭷 p|||ddzzRhZ-h*  UՅdɹTiʳRN茶oMԷm{+rS!E_$,8!m%4u!kESH` ]3n|UJٔ_3a/NKv{߾}$itzhh 7l˗ [\\gffb67HDc0"[3 X,.2 v(aEq!XTjtt3tmv\T*PTKjZR}ttUfU*j4H9wll6M E.k2.˼>cbKΦߺhG KfJTKFzSde;9uKT+/5M `޽X&mٍ:p'Dj8Q$Pn-ZȬ(E+s,Xr;5c@S;M9Nx:.#,z}nnnzz: \.n&HW0bؓZ@Fz x*"0[T`(B0555::zFLDrXҺku0rּtT{C*%dCt_+t"U8Gݲ_4&GȞФj$)}^{}뭷.QTPG+0M@P"?t޽{#<϶E0 ( 32@>u]L\a'ȥkB9 I!|Z< wdyyٲ,TNvޝN|X\Ͽ Uf;pV'(N ВS 3'({=QZ] L7::XJi/"ho͡IXT:tݻ3a IDAT=K:h4.0 z뭋.juϞ=V+i H7lA:o6\[KsU*q2hVC>=zE3m"l6 %?v'2^^d* O5LOO㍰1HzRRWBDmt`Q)wxрoOV(;nteNOsLj}oo_ Jyf)v(-"Nu440p^N:.FZTՉW^yh%()Q$(rKG3]{ԝb8Skw)]6:AGu:XQ{ݺXXX " =z4[5<< |>\.*@mJ% L[ ";KZn $HEѿۿwݏ ~6k,HwL.%\q8)GW'#Ve~V-$^H\}YkSx/QQtd}6iU'xĞS}*v:wM\>LD.%8\5jݶj:l"JyaYgfqHDF, c(ZǀL˲O?i~v/~~2 ~1*J08 jp;47|zg?tYQYo*ߺߋm};\9 ;wBb8H,{AXJL^if3\=k%} [vϐ Öma4>Y>>VA:uW/_veh8Q)T \ bx )~ הެ KV}5ORB/*ZcQT׃ XZZ9?<~vh`:~f9<<\-˪jcƚ@y LC.;|g .  <8 X *;a(3_ zȼ LD>"2M7sӿ3T9kGEػڬr~{E>aM€gYÝth;Ƕs=wϞ=<Њb3gbn6` 0&a5J⋜A6>:)sB6:: ĂnHF^z^o@z1q'>rVNZHIՃ}gt#!Ht$Lu. MJT ҪS1onf3bw{hhϞկ~_ {ݳgI, E .-0 C9a ~H]G>Y!W{?O؈'oѧ>)w#~LLJa|;^{-dHx~,O^wu,"690 dت2Z3S܀౹%8t 6HZs=wttK/=|ԏz~58秦Pss. MY*A*/Rŝku5#-㠪]1Y凸\lA4l\Qc?8e bJU֮*TlƉWz/Ї.袑eExCVHf3N@"Ӳ<`d @#^''z񡊹H^B[ 2 1QB3b'PK4gff2Lf5Z%q玎s^›4=RQB:5CN :@ ,>$VJHz#8؃HDR i-PsĮ벤:# TPbiZ}zz@b6FK`r`vI(q$Փ[x!r=Hd8#.So&8 .RBȥ!R<3\q"N䛞J..$Bzw*mICB6^ pG\ykXcpAD/]wubFCÊ|O=_DOַu 7HRxVEs='u]wx`&'>y c uJH "][Ѓ9CW// _}E?M7Dq^o~o駟[!Q=3ԝ~'4/ko~?OD-žN0~ #Ï iJ~'.qzR%Wx-1' k(| j50vڅV x S8b,^ԧ>7x>MӾo.o~vo>pgn&:LJNĴ?fĥ/*t&mJ~ڧ,\|}rm?VNkso{4Urq bܥ%L5៞! 'I3BHY?9"bg3ig馛+&#ox7ވUn(+*XI]u F,`iJ5O*y} WyJMNNEڶ #NDnX1e;zǦA  i%YNW^eS7Im݆\M4vmO?4rR%%,p*9kCH!NTG,e.BR%Wqqj6%mJ΋,HD1 -X e1nĴT'IT=ܠ(ufo}YO4<<Ǐ<3}\\El*UX .ޡYV sdY 0Jae $ }zV^+1JRo}%"#<2J=pX4W%Wqz/S%W{&ka$E >\.QV\a``IrO/h{% ȥ-K NddDi "NUr ?U8!O8(\.GDȀzScX>gT0`MQSBUV⓹=r46~_ȂFDçY\ũJOR%4t:m&˼jAL(H(yjQ"JoƟznsgn'|}M~NE<4B'IīrĪx/r 8UUp әJTסJ(9r 7 rfEY0hZL~9&\ X"AY\D&%7@c:finfxsV3Dzqxɇzb4ݏH؋HzU zp_x`X ꪫ?|fz:Q:Fh4/D"tNdBit.TZ"P ^7 ȩTlbbg]*XDž kt::2~ӟ^uUQ9LNɁLvι0^TQ3B9qOj!=)|0KvJ|X+'Iw\DZȽ.<)?8^fN*HX.cyyN|"|KcڊZ+RYW?E*T'(ɉD+T/Nc P d``.$V*yD;=NgGhfN&:ue48zwu޽[Ӵ|衇{1iow}W>)-Qy<ă]O?4;n IӴ/}KqBD\%sDBC=$M%iJOLIY}TqJ"X+$l_ZWA#YeYSmCߡ$~;P= 7)=Wji8LI>.r9 bc> ~aB@?'a'n#UMI;1T7'K/;e˺nCS~vt;ᮿ{..G ľ#rU8[2 _CNKHĭApxzƭbu^/?Mfى?Ilzn\&g|W|Wm|_^(- LELkWwx<1nV酷r r)]בEWU"z'#O|x}e=)m21>)[./9Kk\MPUru7:Tƥ72SKD=yVM{Um⎺tM>,q$/'x;:J/} =' z>?F?y8c䫮hL>;ʷY*N9:yx/+nK90 + 3#c=V(kn?T*گYU >[uM2>{SND3 f讻2 R"=ȊD XYLqD(TFq]*y#ս\R̄APsXmC +gf.~n7!$n+zD>^%DALu6JArg)dR)x9{}FI_yi( n=iړO>ɚIO-'A\;g*FDxh*NR(2CbZ͒?.:6IB3$ < ƿvi@sFkN|R-R0 Ur5|Yg۪> /UZp-B.G>=zHF|}7t[BA<#=[o5 C`pp ÀԞi?p^uOO}8JRO[@] eRyl IDAT4߇t-p%B/ nflU,$>.MG\RMESUXoX} *N77? D͐E`H4IdūquUB,hI *ּh4L, D">^ס_ELRhҪDIݵGs 1?gBb#MU=6"twkTܧtHcvꌯZW9wuxl#ďجr+♐X9xO}ݽ>w[õMZ)з]TWƺսU%߸@(U͂MUx;D㏋u<<Os 2{'%O[0$Z/xYR ~=ϯJ Jz} R%'5Igwڤ!\t_ݻYŕ(.[AyyPP@$UDxbBo}ɮO>w-'sCN Wxy"[O| ~,/AR%ԯWe*qQmp bڦ-  u?}'ɍUU\ :-MW(D|>Q܁઴TlUEM/ƸWTv'ċW߯z3t8SU[q 넩E ŰOī'R`''.Q'ܸjq <)0|@CΓW8݋|,3TPbm!U̠]n!'m$ wp%}DΓxNNm+E4$O *T8 Of&"W4}$>9)ڴ1-'Z9&"_ *T!<Ã0 1nT*ݻ)eYx 0ai6hgF6 AUF%hOl4YODc')#"˲>R5" [Qv{ذ?'+,3TPBŚBHȫG.jSev.IE5&lZ-2I]Ԟ`:8| T-0s۸DI *6OX<ϳmnÐ0M+)jqkǭ}f%xD؃Sx?x8s [HZ"IW^T!5MI/TB ʜV :FXgD8w$/KXLk?b{|ۡ(p1RLA Q%rmN]8PBs&Rr$AYf) f0؛+pRB eNXVdQHwǝE)CIe= KS>S%"MXr mz.(Qt: A%% 7KSB knU<}GI5:#hPN)Dz^dsEJ7 v L*#˙iYV:8e@UuHsZB * Tx%Ǟ5E#C/0Kħ8)k ao3DP)l8r9ƒ irͲ,<Ԋy8Te=*TXsɲT*߿\׵,Kچ ĵW4r1@ei%,;g0\XvB<(JjڡuYl  9cPCaJ *T-ze$A4vY|e; z~7yxH&*t:(eYL#1,qV& Vla602ضNm۶,Ƹl/Y?Ka[)DPBz)Q9h4Rq36Kg]GcFP8n32qYmۅBl6:^/YIviƿ*TP?lNCCCbN| >\D&jOPL"Na !S\=Cj\TP(E[Ŕ?66V(48PGVl)pRB5 (ah6 b$j$Y2 p}#qKa ;SE96<ƱJX6MZ N.t/ZɌP*TPQp*48Ikn\ k8k:d11*p#!gN"uB\1R:nZ)6秦<AI4!>kEz=I *RM) uMWa\..;$҉SGFQVi cV pj}rrrjjjjj4MjU0Xֈ &J 4lKM *֝?Qd2w0RyJ%" K-0l{f(_$ʿR)1A8NZR-2v]VqmNwڅ--&$Ң'*TdBNj5XH0*>] Sd?ـ aI{T.uXﻮgl.aj5t:d2 JaaE l , yRժtGFB]6@VN*TPQ|QS zJp^jZhꝈ@$P*X4D 3!0p,-E뺨y*1ţnkSB!J0ju]a`T8}O TPbs' ЊӬjFh=. |ORW ΄Ҡy&}\CJYioX`۰!wlJR.1;\;˲0dY\.j9h40Qo6JP(௯mۍFP(T*L&S,lJӇBX׳l&YXXx뭷,r(eFpUPbCU>U(.ND1::zYg!DijGtK6g{T*%*,L5gΙO2 #]l꺎z;"9k6sss޽{zzzlllhhr]WudD"jŻ RdKmKKKzݲ,۶UB nj _Z|D rZI^)ru[\ fhaKKKr9۶UdRRӁ](_fyqBKJU *6 |E]V72 ʼn Mfgg'&&@NR|4KڶlfY)R[t` B,-gNPv(9 MZ%t:  qPnisxG!@SD Ge۶,dgUI *6'e '~EeY s/h4@7`tMl~W!Z  ?0k=-%l6ki5 chhd|8MLL,--'BB^+hYU*fggc6r(j5M "#i6|> Zb 0DNxF1i eR*FDh4DZm{߾}###A۷ZbM&ѣGSTR]ZZݶl6T c6( PB&mۆryCCCǎX\\ TjZTBǏ_T~ARu0&Pk6L^CɐI,VĘn.SضmuGGGq``xgu(*~sNՂQҒ8o|qllf933s& |>`r)pRBMd0NRJeii />l$(A1E;Zb27N ffDQJDL<)aR0Į]&''!fADx_喗A+L }׮]SSS02l6:!*AQTB he]j9WF]hlJ'bawU݆^Zm摑MfffC8VѣKKK0ed2п>YϫI *6'>Q*t] t]?~x\hffï8 L9 bl9b||LlT!b#8+"o n8\FN1̲~;tBxD.4@n"4 c||*'*T؜`r8&!Q.щ ޻wo6EJW^y:tH|>gp˿H3q$gZ N8~p12944ADQ i}ǛbkzzP(d2Z&<:y6ƃ[PB (jvX,B`||quɶ, :9S,ђP(@{hh\.:tu "^Vc" D"#qˀ P@f:,#AN ,TaDtz||<" Z NDTjxxxfffffu]˲ B.c!0 8PB& !pfBζZ644]bJJ0EQRr bȑ#/--9r&&&j&ٿyxv WyVt!mB9?K*|U^G!iZRӑ#G8of\^^rCGD\###L>Y%B [Uz#>0^{X,^zPA]qІٻw(tjlBI^N$Jw.a6xȜ\e3VjADDR xHPl4f ST.rп9_'*T*dBzT(ǧDg HE4 Hq*ilqr8NXD&z 00+α XKF0 XTUqzZG,σuqjD.ceY2M|"4$**ٶ}᫮jff$y|߯jXC 3::5σ:Ӿ&O$xE6$ b}LGEy:C>oDLBaxx$ 322'; Q3'"j4bXݫz^/ØQySAtzjjT*If(ϗJ%P0es0R%i %A1/ja@3[5<<< Ou, S {Pmo8*N*v8O*9>t722XEoT\PPZ-Jܠ߃^X_bIT"itx0gF;*ɠ؈\}ȿ$(@4GJk(ȜC8˲R$*1!ͽP#}NtmN^g!" a]L&f!l6/T*8|'X7-E"ArTŽ[Qg"iV 2ExĖЖ% IDATcQBILN*vL0 V}*vP@P(@h||ΫVccco6 i èT*>ܘu %ɋ !xzH4:.//gYTZFGG7 iAjHPjz*vLL ;(3ah z###޽Ǐ6iFV>gy@ `SZ,Rx /SXDr}?͂}Q'@mq"B/ 2k\LԠ. S *Tla@?@ dUlL r $(x)N<-[f" /2qbp"0'liI *<Dzm6 qg~~~vvCEWe5l<(6$Հ1ŻpW3'*T@WjA2|&`D Z"f <)>$;I?)mBm9=J`q|RB [Z-T@`UӶm؟#6f8p FRڔ#Ѣ$x eYw_V,RDDZ\OUB  ChAAm]׋Ţmztm",Vf?& pZ#<*R(1I;d\*sRBRÀ*m@ ӠiuE0 A..;1#t0RяV _`pHa"L*pRBS3q~l6A:Z_2`Y^6R!W!$%}&=J\I'xmǹZ8PBŖ<!ۋ4- ndNDqQUe!c&6z%sH$T/up"k}|L4FoR¯*TPq%:. E-t  KqK’E7"2'*T8!u`n  ;:4?!;2u[JDH' I *N=8A68)17`0a`hYym> q|0 TPb }Êπ*pbn S ͧ^i3xԤPB &sd2mN)rKȖ'Z#6[lxU֓xʞ'*Trpj%x'IMB IR">QO%ČjUPb  %秦 h4< W \.>5+!` %% ʱ${7q oOlz_R *To]Q Trtk8m: ƉNhSHIH*pRBNGao݂ ?vI,Qt7Ꟙ!I/O$Kة"TPd#p攨-Wpb˰xO<ގ38TO)uѨPB'6x'-q%c'U7rw|k%@(I *N>Q'€O(Dhdng}Uqj?[S"l$$:(H!WX"!,PI *N8A#Bo D8x0e ԫ֋$+apɑ2 ?ab"'*T8y9i3 &X-WĴ)QƤIY ,6ZQBMl&W_}jFX_g4M,+͢'1 D@qS+4E M@ W,-Y](/gCy<b "-E[ոʜTP$! \7by9M;PܿʢVDZ9Ï"I7)pRBKXs= 0Jkʹض?$zI"Iqa璐I_z*TPqhj\r5.+r؅a"MYyG08{b h)pRBN5r娷#gNb6N4XYAAg,;ivX\jU+^S TP$oKҮ]zI*Γxd; pb9I9H[O0' y{qIJ*QBQA\^boFJ2m'O򬽰s"-{2Bu&`Q/ʜTPbCs]7Q5'&@W;(b󹩫' ߂mAU@bRD/N*TPq24M(RFlv'J7{jv0 ˲DBvb*#"\/;h=<I&Qv4Mф abt%ƤXЖe|'Iz*TP!Ǣidb]W>4i(.1 V2_IBrl}> T *Tpn9EeYMΓL"H V7JPE+]kE"Q<1KTNPe=*TWa=8EXSŬ%'JX=$9JU- )iJeN*TP!M<)?>Vh% XQ0iPBŖbl>|jʑ& E1￲SAPJ|!D Ʊ$^Tn"*pRB-Q~*"~hP3$>z/#f">#P^­5 m⁩ *Tl-8ၮ/iZTjZ NkJO>^NJg70ԥB [̆@yai?~|߾}\nqqqhhHRd<ϳ,0 u8ml+[vP&5˶lG~O/p~ljmI$T U}HayqDQ)y Bwb+qd#)EZ,+u۶i܊{WUKe96wj&~SɥBN@ǀ8f0A,KX]-B]XL&F f|Xи+o9Z-q9YeoՆnqT[igrIK6Jܹ8l6s(lFS,[yifYYxCXX,rBlQdM9B\t:UU™ikYqxF=3 2f(Ԧ;eI >*ܯ:lۆ`n@ S^Bt(‘l6+ݻA`ty@WTmxn ebZIx  _[O?eYqSC7V|>VPeyC+HR(n9;;;==8ct$} ny(-^0GUשj5Z!'Q{W,BtAшͪj{{{8-$fyev\j*˒*#ǖjz1E >4y*4M&tʲ|˗/ {nh8</K<ϳm}uRJ\M6N4 A:uIrs^~!ɞ@ 9!oiHC{HPUUǓd:&I8v{Q{bq2o-1WIlTiy] f*'(ūr]7,˾+w@۶0znHSP4 ]2_ߠ~LKċ'ܖ='@ @@;LŋϞ=s:ل`? C*\׵m@!MS(IbF2kMEhs U^)l֔TN@p|8jZ,d&D=1˲|%rAv[[j)mux s%$ $7@N* ò,iݼwPR "S>@XrG!| 4Q6{92ɄoS6>Zq8Aӱm; $q]{(0ۄ '(I3OGGGA|:,3\8Nx G;="˲/ā4\[hN qfdjE'7Y<`_GQd2!F 0{-q< E}|<c$vX.Ap6H9 uXjgxy&I37~NcY6‹ E1NRYEQl6KӔ ,b9k>DZ4MymIHLfҒ5C-cABN@p vQlh\:SeY hW0'Yq$6HODAg9_ Reu:ں[@CmE@zC~+!ܒϛD__[wvv8 8f(ে&AxO6?y)PV+Ewx< NBk7@p+@1JJpt?lbWdd-VJ@8zzI/^//v:H=Ay$Iܡ9$ " UJr xhӱ51^ņ"LV'mz!@ ܢʉrP֐os@J`Ejt:TU R,ˊUR J/^@M% $+\ac8y@I*6vⵔv֑*h.¹4MfmhG<@I@t7[l6fpVBz"㋋ :Ã_ygiힴ֡!إnFǽ^e`RڀclJF_=ϳm{:Z5:!;T?Bd{㠨RJٶ BBET+yj#pI xo|ͿLФ "A#(|nY`0,frA$ǶmEx<&ɲ b<~DbJ8 a[W \ibH71d!'=ew OX@^DUU 0 ,qŋdRj>c {Kض,PFrD0Snk.w@ $u$^P9؞ jN\.y}%`|$ -~Z&61S-ƃrd갩€Vkoo/"Xx<GEO֔b89F8H! yOwK-eb[SBN6~– jQ|>Vd2MPfl! "Ԁ 0o Ci9WKzP& 9 BN[qZa)h-aa1/uqL@K' UUe\ԺGMZO]Vr'ZWY%Γ8DBNOx"!.oQqw-UUnRoBE2R T$}p'58mmiV{5{2!l6Yi.a蠡B g\6}:)EQv8!CɒRʲ,6qbypv}}*(?Z"VjOzt0.xwr)@pJMY8II+PhG4;:rY!"RC[{pɣ[CIDAT'L-a%&? 9eľH xoK/|n\i۲,L>53pj!$R t|ވ ѕ9i\ěTKigI fLR9 >hī Nfd#zm*9ܪ™@Qj?f$^9[Dm=~B_Q JNW @3F FaH=88F򪪂 kZkV_:TSs'p"QlI0 !Dya>, zTǝNKEQLAj;>aNL`,2L5"zk$;mz?!']I۠*J*'v 4M(BPej4H9(BcyNՄ\(Am:4vYH B >h{;,\8ff3 FqzzLB(񖆖TUUQG$|'O!ֻ$2V?Slo3&5>iO'ԾN~ﳤ>LX)$\ͽ7 6RE{{{yOX(=ϳ, >aD"ANsBƕ败9GP25sd5e=V*'@ "k!SJ%IXnvDeYQa2 ~ 8 㴊pUU$m6HC<7{l (ܮV*i&BN@p@ -FQeKI;gnEQ v\.8QtA)pDlǏxڅD*Tk?Y*z:y3]@ ҿ.)Vcp`v<C$c)/2c:mee#-JjԺVՊ4nK#S<&HݧLg B TWޙw uPl6(:4 Paܹ@I;i T& >HCF͹,x*I/T=2=}2oX1!GdYFd2!p0FYC>@EQ >x˕eYb*,cK[\8T@€ &bpRrсOrősካEg;;]btK> mXi 7zw0i-wyYGDt,}'W!m6bŐ.x? j2ꁮ`<C$˞@ BvV Gu4MBR󼯿}8Pn QPj7Cp>fz-E~,pfxc̤ݠDi"*X#EQ@@{6Z,~:3m$ RFvTxA%̇B [hnkK)m=-*z[b/'}۵zm,UE>/PNTad@ai ȇIf~#8 Fi6؂B*2O2G~O@MM\`qɲlX_?y,ϟe;2r LXiWE$SG(Huy"2ɉWWcqSlA:FĴ d.m${[,Hr,̶E7ovG~{n.N V3xlKi8'NaLF$%!8 9 dőIp (p]z7|W˥yc1Hx9Rġi.K*8Z(^^9EArk@Va&'~B:,{{{d<cuv$R@`5RiP 7 }njZ:GiZ%D˥Z R"ўBEQih4\ׅx( Iܺ?&3*g6C<\Oj~iXoW\pO&B,˂jt:,0 ?~׿ղt pѴozkV='X!z }ymmܣ·b]DgH[kkZ0ԫ!olR}&$0V.;,@]Uu04M=|xxF$u3B Ah%vjyN< ?6Y.-^cQIzd'$H'(JkPȺmpb}zqeMXs1^JY|)&Z o?Üɦ 6BQ5 DO]C{NtUmD$񢧐='@hIv==\`۶m=~ɓ'J8(fl{m=uٸD;eNSqgQ!w]jy(2ivV1&!x3@ \& !, q=zɓ~?VQXC-ӂ۹Ư=<*Ua|~~,¥jynw:aq`ʲ 6F7=Tp[ [+vډ 'i\ϩ9'*IN/$5u9t&D'oU*VU^/M`RzZ(q\SK)wcj_\@\VkBč+YI+$oQi ph/o]6]#J(NN5u0tzh? l ȕsi ՔZO F@#)$I 8>><όM 5{wfKӢɬ6Ųz2FkFK%ם:/w@t:ݻ)ōS9 vt̍8MǝU]<Ǧve9( 6]`hRjœ6,lj鉨cBN@_SЯÇ0ǴqB\B7-G`š͌PM| vaXFՒ(=h_}q7!Ps,'Oh'*bXp&&J69]SDyRMa[AQs9WO)[[f($tN(I?1xyPBEeYxٸSE xnӠ61+<0^ Z]Hŋ*sۉG!'ZjeVt3oz6պ(3ˠ|zs|oY\.}<˲l6Fxᇲ,ݻwݗ/_%HȤ78+[SVZf,X DElP>bK؇Cc!Bbj\* $˲`)SYvv6N,{h4 m@8?1h_GMzIj7!4TGqeI 6.\Y`YVO eYeY;;; ``v"u+>pWVoCKuFUU}[3g6 Q5$uDZ/$ kea ^Kt>EQq4Mqyv;bo8r"YLfBx-lyj~hU05מBO7t#1U3Oe&+CxR@ l~˾c0ߏH{ & s]Ν;OFFVT6]=*.ˑjٮN&9'Z}.mC!'@ X|W{HƑ^P>@iQ&4k~QКi:͈H1AJ4Wet:8w[iI 5\cOG:E`C^ω3_Y{KGd!\b rl6k4Bj(GC)5ϋ 7f9ө8OsbK1T MH kG0=Cy^=??NQmqLz$ Ve7SfO+ުeI2.rsjaRB*N5"($䄯`0 9%!;(ctu]ҌJnnggg*?χaVbzRۤqdfy5g7 0zp ٌK{m6(Agي`0N$5~˗$I@N{۠F1L,+Cn㜊IjmiJʭV )lA$x @>N\W{R9 F`sl+0a( {{c\p]psUwݯ7? xp]p|oKw뿿StT׷_,RU7ƻd.q^R\_/!;û?_D)ur}]_w_WQFJ+s])oe.q.r n;N.箼IENDB`iptstate-2.3.0/screenshots/iptstate-ss-old.png000066400000000000000000000116351521561511100214570ustar00rootroot00000000000000PNG  IHDR<X`\yrPLTE~*8LnnnSoSnRnRm8KeQmQlPlPkOjOiNiNhMhMgLgLfF]~CA5IDATx휉۶Epũ=n+ $p h'G$y/8B {Fs_ wyQ_%~oyիWO'ث0w<$ [I&֙+5_m_osbxh9g0/LƹacL[q0;`3__<_|i2e/YFNK0/LƹŰË +8bz˄&Cv]뗑ĥ wg|(Fĺ}"?T&-2G$8]ԫ -<*N/E;eY@ŧ/,{D4t4OlZ\YfO_0ӥϣF?yj#yK!RYJy,'>O/98`|\6Cy=ȳGǤBa]Q Ǥi<Y\2hь.4<@bT <1Zer=LˤLUGM59=Rtne){c W?dZVFEB 70>yϷ)fo4QHˊA*9Yc홦[uֶ<ڿ5Wlk|^v??E utYt'JEʙ\Q/3zஏ6 vǁ%mwmAҠ|TnW Ʌ<C`2I"[j8YKQOз鮙KuZ'eN.ZJ7m5Tr\l/=aIr5ۤB*\cJ壨J>4B.Jgc3|M pʊg.c2< ;<[[6<涰ҌO{4F^gRbgKw֭<=ٝ'0|.b3+URfxŶRy2̪sʓ+|Ϸ:X[N{?1=!Ȗ<2yT'IGf碻+Z\FGi"8Uڦ-B.toru¯\PD/^[=yK{q*w%0=CPn-qC`'F[eFcZIS;umyD PbM7@FfGVnE_Z!&FyZ'ݶ>/HaGN\C<<y(OQǵݛ$\0G<ؒb!Ĩ=pUZV@/#giD5e!M6'y;v[dKs[<˓Ӥ41*GI~f~BCcb^XK鉖PrO)(5'}[#i snR]v=ΓVjEhїI5ѳ8ozHm^ ]81pu4me+9R1Gyy(skި}m q>Obx:p;OCQrYqpZXlۺHi҆YH*y^WZ&FŇz$C{Pp܎<"u<ϧmn/Uhsq0٠\$T}Olߜr?!Ȗ<5Pn82׬4LplFFt;?j4\[YY:Yj~閨鉖Pr C`b4Z):n[*'Ϋ@]% gni6ɧ&#BўzEXΗM\feǧۏ #{]p[tŨyZ1(M$F63U~1a0&k|تZQr}@}:cE?4Ү|eiݍ[PTLvg!4qp(1j^Mqfy =ګa7uthuG7:yA1USf%_.(V*Tx"S> bl=Pt Z(LO{Jq@y̱ĨJ_m>a>ʝA =$che b8OuJ6v6AMΔM,8O-jAnydH.׉>~yV@yu z-ի6mȒfh>pK3/FbI.~PnȌGOtQ%SQ@vQ޹$6my>Ґu*y^օN+< 9,SӼ<"*߯1C>_g$?*HLgPǺ.,[dKs[<ʚJz'F$#39WcQIʛ{5$$ 9uK%Fe*蹃閨鉖Pr HiKHPCy !0PCy !0PCy !0̪C`(<C`(<C`(<C`(<C`(<C`(<C`(<C`(<C`(<C`(<C`(<C`(<C`(<C`(<C`(<C`(<C`(<C`(<C`(<C`(<C`(<C`(<C`(<C`(<C`(<C`(<C`(<C`(<C`(<C`(<C`(<C`(<C`(<C`(<C`(<C`(<C`(<C`(<C`(<C`(<C`(<C`(<C`(Y!IêKkM ˈQ_^D,<C`(s^;UNo6IENDB`iptstate-2.3.0/screenshots/iptstate-ss-resolve.png000066400000000000000000002067611521561511100223660ustar00rootroot00000000000000PNG  IHDR4nX pHYsaa?itIME*` IDATxydGu'|oD%Uu- ,f;lj6ǘ>`l AČ HHnEյgf^,7Uvf]j :2x߽_ZZZ=keY|!eYbeo&kb !gCާφ !BH!m}.q%; i`!ڄ,1u鮟tG gCtw!]6Db}`uk?P9yN<s\׶mqv]^ŧ?__mWaWL6!k*!*َ+"dbW+dYҭ7DjcW6X5CĮMb!d? X"ԅ1mtw[۟|o|rK>=㺖eN=p9Np;+= |*A{Mx $yh@,B)KI3pmN=p+?{W/{~E/Z~O8fpz?{ᅋ y z{w5pBPzڞbx~[ڷo2w|_3@FC>1Ɛ T38g9튰:o᜿/dpxzz7f²Nw7p=[gϞ}c^sڜQ!s (ڞu^~c뮽M-z#OZBzdI5',BvϭŮXKӫ_E*G?Z)}]O<Û6]}_ozhQZzK~Xe{XKe]־=p:4$<c k]wt?O|_0pn=;W^ }߼{>W_}k_-g??_,׽M(!Ontj||GƎwt{2׼^Wd^җ3?}ہpx ^p[2::Z*~|k_SRL&󊗿|Ep+?яؗe\{m|hO3y׼}${?;]r|//nڷoxxcg6>>N7mo{֭R}_vT0C%ďo7yhhhff_w|_}|/ O/xA=p:ɶm|)10#nڷ/WY1pn=au__m۶}{_x7^s͗nȑ#pnx{{7/W"뮻{]|qX뮻w7y 7c/??i,myӛn喧zjK| g;Nw馿㎦K/}ߟoIWjQk.ԉ'o~mzСH$򶷿 7p'>Çwy?|{!!W^y>\.'?yС}C\|peַ~S:|H__{;/L(8AӸ-o?#GkG>Zu}zD"z׻>'끓TL}֓@˜wky]l }z_Npz~x|lk_Gy޻[O:Z;ۺy⪫{˲wj݈x}a7-;R.(ro466ǎ\wugb>?-Ýw|+rG +}O8j_W7sܑ#Gȑ#ox[,?[~^w›OSǎC\.|n;{߃IzG{vmo￟?~qT*~wyڢz*8sV ݭޭ1㎄O/A˹u[NW=sS4;3Cop'uؼy',!.}7Ŗ絏m۔`̶mێ>Owq-@+E1艮/|__O7=5lL_]`S}GzSSSvz'7p÷Mc5^ [n馛w=ݭ7~ݻ?pfr=.rru3Vdџ/| ܿkd||޽g޽{O8qZu;v ^{ｷ{&/zы~ӟڻw^\tEccc zrZ_[o;=^F[f %i=B7q7oMow;Z%z?K_ҧ?|-Jwyލ|wmw?/QQ=FwRl6M_O=9rW:v?aL!Dض=~j,x =dss߿>&Cn׾ux;۲-[liaQ߿d2\;<=˩N+XNhlXE{k^`5hǗG}K/]?SӾ}`3hT)jKss[GG+_~)polHmD*'Nߗ袑3Z[կ~ַD~5W^;/+o$W[Nw|Ç?7WpRرc{Yf Տi9ӞgYIQ^霴gNrveU,Otp6K.;628]vwלJ8i+s"mСXN~&OJU۟WyNu眯0("Dӟ>yp7lvJl<}޳]Ȳr3,+g#,-#o|#$g 3y:tw6,&+d19OJX?wL{ZZZZZZZZZZZZZZZZZZܰ 6ZG,֢kwcXf_^5מbc:@, ROtvV z7[^^^YNkl,e%t\\d>bM}<å6+{fVzm.ƀ|h X-\yzN3ܿ/7׭R ! YѮDgШzkv* ̊(>=dMO;zzk mt'м ƚ۶1k@to̟t.ucL(Z7jB0Cwlalۅt?梭¹mͲv\T&tEj~ѳCNG—jrVѯr貜fHjRJE"zmhvڅHh4u]0c\.W*n<3o^Od2d"]/˵ZͶRyeY1cL$I&U*BP*R {kmQ+ht[;9ZNۢ= ȋ6󖗳QڢrFu6l.8(08RF#m-Z u BBJh4: X,8NRVm}`~Sv !Ţ:H$X,VVFR!m۶mYVϿk0,zun |݃<) =mhl7e_-a-o-ڳY Z6 %Mz/^,YGk]e{cs"*<c֚1溮8d6[*Zrj9/"6Os J233yy 椔CCC[nu]w~~~~~Rcמy"caQpZ{ܽF>o:tOQgݺ\qzˀ~ku'Xi52bK=`P@D˲]T Y?cJ))FlٲiӦÇ;㺮ylVH$8ã9TTZ&qmBezKif-1ùt&?ZIghSU;w:no*ק{!DM# |D)ny޶mJRX$ Rj58uX8v /rqG700HxRH$B2Noڴ)Hd'N#mZkι}j^YNKc9-6rHb?u8C,v]|*/ѹVCgELZٴJ [|Ⱦ zZk󤔖eT*L&-ˊbZ-*FF="DmDFcbeynrP(ɓ333Ӧht֭'NJgN:)=˩~E l{lZ;ٹgJX+:6@iҞ>D#XZ#C' !,fO=T ^*"X dАDN<1JxHHh,qO5-*(G|}Rڟ#f&˩]N7zEpUJ)9 tkVie$_XVYhv2$ FXvKwkҙ+!o\&/Zn+貯XOwy ^T j"kӳڡwjuǤ\FK $q[w\[ԁ(:#P >N Ljȑ#Xlxxs~l6abH$fǎȈyXltt6 Dp%V_lZtۺ=sYݗ /(o)`2<>MpZ{۞ၫpMȷ0zלhrDՀ __d2>|xvvֶ\.OaِcX6%c*U*{Ah/JŌ1[n-ӓ7oNRJt:M(x1h6rTx"S >2FO:U.L&3r\sssD٠`si;jcӺEXQӱNr,c70l>L~0ց4cApnbRT 7_|{졚 B;w*ɓ'1lZKEUur`AR >jňOT*p8<44DyrlsGFFjlضm٣t;2(Bc;oň|AbZiE(,ِR8+\h :tVG5RZw4I2m쿎"72 ZsM-9mwn}lgO[>Ʋ,۶kU '5Kjz!zNXVK&Tβ'N8&6y8YRn788xR$ؾ};:a2,:RHKR:WrL?d2yeرX~x4ZL&Ze.皂%˔S3m Z2 }%[1!448NRGP`N&>71J)"`QjP i5072 o 2l:+ Q-x0hX!bjm`4RNMMz1 `n2.,mLLBt,!vș֚sF-!H[@p  8`ƚNv 2F0fXx! bRZȐs&!/} ƘTh`9]6Os0ZksӺe&0b4I4f!5)+::~?B]`JԆn'ztfӧ+ ,zFSTT*T|18NTVIJ BFcrrT5<A&c,0 WLz2U366v)q(u^J۶m[2TJmٲ%QuA#A`tk⺂1- B!*mr}1dZ+,[:(@p.87Ƅgxx8r&Z9C$]`~T14aRȚ6@1hFH+sƚvѬ ٦EZ"cMYDgBXMfZ;@eѩ=Cl&o-ҳ3I[&Df PdҶ yTڳgO<Gęy>?z:рN*Q<uZD% 48QUF]p&fep%D8 RFG1\*JPȭB1i ƀ8h ʡH/qΌZ J]VMD#8CcA 4FCZ{" B.-- I-ӄ HO 6Zkt\V*xh"燶Z#$jc"k kY! 4=~ۼsJ%Fk48D$r$d2,Ng!06yk҆~󜵞cL0M7 ''2GcJdUG(JJ^kؼ[kYN7z5^EˣnϏDZZNUgmڴillP(r9*Sh#PP+$MGiP݇v TH \T*Q~RXVT!JEQh b,:[l/ 6mڻw`8n4r\.G<۶ÇӜ]F!V 7mmٌ3l6O׶8cxՀ/1Zȑ#Rmc33m<+VAR,uL*<[.2P+ ph4bZy -)eznytJik`vl :p4 +RR8~Wj5¶mPRI/M|GϞ6Ny }4má}m bi1mTd.#~%ђݐ)TJcc B2%۶,a!_*_ҪhC Kh%:Zy -Kض#ĝz| r!@O[n:LԺ kٙ: ZS2,GX BTq*Pki$!IHD ˲(ba(fff^a*DCy^__@X!8P&&&H]ֳd~)0&&& $ɾ>R"r;/zD"NH(0yxZUZsLV\d3RɩYchG۹!c''ffąV3g+#X,dQ0x Zlmۄ033F0(577;95( G,kd&"%j5Ιe;BX Ԇt$ADk|1_,dsRBdPkEB;w !陹а:TJ\P`a`V";wd j|03;chTp t/JONMg.q4ZK߀1a<Mbx,GƔҕZ}~~>y8m $؂ţd2׈+eZ>@)i\2:IVӖcsdhѨT*YH WVlq\\>-yjm[ogi xtY+غQϵ(2z JbBPVp8ɔJd2I|y1LZdR&y BY `*UUVPD"DFtF( Rʾ>:҉XQr?yfkZZ 4vrrrjj"gdpxT6Ln=RlNR!ZK mv82@3V.3`ѺE"VCc2[Cx\mgCh \GIa[HI[XTJMS0J֊q4Fk馧L&;'}JM".Ma3"PZ^~EFkƅ6m@ƶ)]9PY-LzK($C*bO>RkԱa6uD"ix6ZeYtZҗ 1FS\nr-a)-;7 VZ`"J{24Zq.8҈O&t4VTX$m{vnQopR)TRk҂ 0bpFku%1muRPHϯx^g7JRk)&kyIwG}ԶmbN <(W(&_KAIX.)oNdjW*)%9|>O>[R!"fff8۷o5cX___$佤}333˯*s䧳C"c  Gp^|cE"QKU,!*ՊF<XrE2h[8#9@[I__rӦa!,!zu-cB!wtt~Hc @9oq7h-ܵ_" VZ+c !4Dv.ڐ*ϴq쾇i__vQ$.bperf8h!D[s{Hv/nꟘ |࡟>O4g(VC8r> >Kh0(%ݼ9R*ױ5Qm0#Q[)5;3f20 l m7, g|ߛ϶qƕ1c#z: Ιe[LŅ1Z)Bضih0_lHC`JR2X;NOW{wHXʓ֝=E}pn_eny.eu\Me>+d|B!)eR!,Pj[l9qD9tP(BĠC>'"R( թvxN{q^*JtS@RFDh0TUqu<rfCq&lF"۶}fccc4UN8Q( áPJ ʨ;vyZn;ꬩj>Υuˉ͜:`0dbS x2eFi 3ӳbCN@9[~X@F0-^u">Ss\]g2΅cT*9_(LCE(gfgk>w]۶XTjn> ^ejsRi-(y@,KMd譁L\6gN1&Q5-59kFhZCjx;2SVJ)'RqJ&-F@dT* JMJ3JSpDC,K\.͆#ѾL"RD.JC\M9că-ʑHxhp(r|7F SJCZFBB_)leQ,LZ4yrڋX[_º$L{th }beϲ!E<=yJ9L&u*D/cL<OkZsAf ܲ,bcGu7or<_e r:uرc| |O$NVJ)ui|\./q6̭ͦkZijsK9CT*U(xW*eq_bRUmKhl˲- cbT+KZT\Ҳ1&7`tÓr41plm]MUY tjv|j/Zv)U<;$S]"rE"={$cǎQU˲&''hZ%w.pzM 2mIbjbNjQT5 0m /<'|s;11q>Z뙙:6JbZFI("HRt.eyJ",])lx 1Im3H$1@. qJ%sSǀ0 њ34jFu:,%3K<\tXeYJ+9rN{ 9#ω1p nB0_jߗ ۶}hqF1maK.߼I+\c7mH$j[V0znDe|e3i))5r&\(ɀQrcLi3C,KPS{\046sE1 BpM|YՅ}_yRqZFA$U !C g 9#K f ps_D yKִ F孥v|j?VA):qrlYV*:uT"pǶٹ! n{n2Y9qVz!1R"J)bRضN,ջ}^pSSSJ&^x! fJ*LB0D3!\N&b^$BMZQ)s O(<،9-ZohRR! HӐ\keU_ f1K1JC$6䜢e9iB7k2ʴK/޽xnO}JmL*>m74,dX`K "ڛm dX:_*-|- (JtխEJoM1fKhiϬ0 2ΥTeh2i"Cf6T9wJr.|Qpa4hKib T{Ƕɦ B2Vs؋s5 !l&6:U*۷qrpBM6UՉh4J./:+6FIj.b$C$J<}_kѨ1X,=9TryllhmD>:V8ѨyP(L A8^D(_oMN5|,POYSS&[$h,۲3if@3d6Z*[xz i t7ӍV=9%E2s+ 1APc2!"P(,JQ( [HPZ0ηl~: `Smȴp<ѣOMK%Am`s;aJŵ0R-t#GۭV B V`6PVCm+S1N8nȌAQT)ixRp+ h4^#c1gT'qȸ4G IDAT C4\#2fNlmy/W,vfD3 9H:P-Q,:B_T6V;DWRRP(TTK/ȑ#=خ].FOxGՌ|ߟÈb TĚJzJ%_\ Z.؍FC)rz:[9@yo[! &|!/`YV8f >  coFKX&RC"P*Wt ΙJkGT2yxh6;gYv_:Js_J hZ%Y t&ھc(`3l\޹s[4j/O;`OLNL2H`^\Gp:~0_T,px/G,"t$:W4fR<)h*vPZ A:?oNmT*s!$+חrTו6TR:n\|D2˃VȘ͏YuVbJka-[6?RJ$ш/%a+)EfLT5͂`6sf h"HJ6k0φG A-S_t˻ C\ F5qV*j9 FFFzTFǏ.h4:55%߳}?[k=44>.H谱\ltda{p88qVU:uMK.~l޲e1&Q1@Q.} p^b|aDrJezzIˉ!l2LƉX)t*Ԏg \_J_KD^ @8ޱ}RkeffgXjPh֓ڀWZ!M,ѭh Sg6?~T3/GO .sM6 E R|P{ N2tѴ5 @\/R>"lߺydx@)VmZQ(4`ȚfSR̖--sќ2EQM$?54+y&FGh0`lIF#amh40x5U3:ؾVoԪܼ>"h ;wlT'ٟyUg~f.DSD^FBiv"(VXTP)ry˶]ےҏF܋.X*. њ1ȨC$"h[@u76 KQ+yHƒ3y,H&YP1ՠQoGw m8j:Vm-8YaRҁУK3Db˖-tqm۶,+͒Rq]l&;8Ũ  )ײ,WTE4(e=x+,JsϮ].䒱G}P(\tE}}}fX Zed}ߏLflUЍZ{*[*:Gɜ`E-JǢX$ ܥFY# EC.8L<tz۶mᩧ* tQ8vg˖-sssĦ QNEK )u?"Xk,FFFvMpxϞ=k<W\qJd2Y.錷r>.*T*tV/AKtP͛7KpW%Gj XTڀJWBBFJ BJ) }Ut# J+:m"`VR2ZEM733D8ahesLYS v@RTKߡ桻zN:$@0F(P .TP@0$fa @E"KEd!@Bk[uVUWܳo{tgv4@1@2(%*rDTP8H2I 派A"RUPuPD".y27ettӲ$UInfZ"J&R %)lF69~ 9~wE 3s-YVd2u>}Y"i"-#Jkl6El&(2hLhnjjl`Ȋ*Ir&C $}}IƈByMSIJ6f5Y DU'Ӳ0#ʠ#vT UQL˒L+"uc8ƚ46yeIsފh~eKx1Ea󵷷ϟ?ω',XL&bpm008WLbSX{C+ xs%> Jp ,M{.d#N<988#'.?U q@!6χB!xRa/*1%rO(n!it:TU*1M"us2&Kh"-,TD+j9sBsD l 4Qe6 6}zRm6"WDV@"T:];z9 A СC>OUՖT*{=\ uuu .*3Qzn8~yM<묳?\vet?rH__… qsE-Bpp8|رK/'O |>\u!,{LJ_ 4PU."8wd%EUTDVTP(-R-6ahJ9C>'T`mqI.)z]Ȋ"+*I#5em"2 !ei0-4 MR$*:dӲr`z n7_3T4{J/wzE*i:/Kr,Dڿ2Ci)[ ]EIaHdYM˒ȣ*ˊiZnȒȊiZ$˲T òehI7LL"*fD\/YiwI4u$YUT" CʄH|$ɺa&Ib@Cu ӒdRd 37T9'3j~lN#N6'c$&iU"J*QKK˹瞻hѢzH$288^AԢF7|/eJpbhU&2pw8z$A9s ѣ`p޼y>SU5=zzcXOOOSS.@Ӵa7`[ZZ ÇyÇR)uLO"mQQMTZ*,*AR{(ѩU$^f.YIi O']hIP+]k$Y6M/XlӢgaё$ٲLEU ] :eϡgPɉHV=0'˦Ijh#/Z,bY===[E)&<(dȲLI%IVeYi,$W-ӰLKHQdE@^B.(%IQ%ϡUzHVZ(bͨYtG(@3.yuBD*vbi]Y.zd%Y&|/I$E?TONUnDJ=v(@#Y9Wd!%aW2juZ6r܉6F)tu(`\9ϛ7A"9t:iZ[[[OOO0DjSa>c$Br(u'nLD^Zkk+*Dg@@U;vѱcǖ,Y[; bX,;@Kܹs!\ݝH$"HkkDE$ j}8l!՝UBJ .;YVفA Ф$t*?XJTQȩ &(n4-, 1|miB:N&%ֲIE,WIV,,H%p/2m%Y,+/7MCUT*uDDd,$ɦqJH0x4BXR*)Flex&M8gcQ)IbQP\z!(qiG!r I"l=5/XjKAFiw*4]2!Q3fL-TטPtrUb@ى{Aj/mQU}Zq>="uvv~h@0|\;v_~qHnkkӚ7(^* ?dڂO!χ/^ ;w饗RG<?~8EQo_p|g$I 5 իKR~UW]5gΜÇ'e̝;P(d2'Omj l&:Ȩ*T:;u8 9-0OxUg!^1=NN3V"Y;By,g+y)h$r|F i@{0uj*1~Q/jfp*ڬFzI~douq"LtE|!(J>I\2LIԲ̢s%EJWQT1I*VHT/VI;BP(rM$ {~x*eUa8H6M7o"T%Rjgv]]]lO$BWW .MRmmmOj===}Ygg' BxY"J&(ND'O -jhh`χ~,XD^2FH"[D4Ç$ 755S4:-O>\r;Ｃ(ws9砞aT*$ `8V"458*yP'fl+"JRl%DW<"3PwTD1#FQaOtC(:cGSLӐeeXݘ,WQW*d%YED!$K;eao<)etL SAy!+ QB%|>O?˺ ;44 Q!@ |8@>!"!sp8H$`aQdX60}h0k:. wE0j?~4X,X_|i0V At"J$}}}X#cqg@!ϊ5uA׭nk3WӲu%>y(^IU7$N"v(J#Dć,r[D$ŸE!4"("ajfXa ,%z1(jtz'*H\BEaؠWUE{{{sss8F l6i3gϙ3@ԕ`6,!( CL&h4Boa&J1faln囚ԌìHA%q&\*_gg<gݨdF^_+đ,-YKçfeA \?Y.)$0`Os$8"@Hgc Q,0E3)5I$WBJKrk*̦*rݳ{E8xPh>|\.x!\x{N<9o<@tpj?acǎ]tEz>LDGbM'FBeéTJQ  1"0b^cc# >`ܹH|ޞ޾d29<<~ ~TV<8Z%*ͤX[`e UeihQS)F)ϰۊ,mg7x\BSQT#Qɓq)X,Fi$U1)=srY.>doLA0ʧ]% U2F&g%K)믿^QL& b >CYQ.ɓ-R孷bŋ{<~[8w\]{z ^x!u|;\x6˲B6gD|gI!\*"aCCCsW,\C7wytúB/H l6BE+\)4N(QLО`eTd-"2  @$Q VB$.g,SbZ<qMFņks<.\. V0Tj``B CCCxEO?E>kjjk:`T( *atcc#tO~?d7ܹs^o8Fޏ>8|i /bʖeFV)P/Aٸip\V IDATD^`$Yc XXK6 qY>|@{B*92w@ pBr9r$,\4O? .\l"8묳4M @T^$@[UU(Q.pV!lx+4M4 e4mll i 'Œ Il"[رc}}}iI8Tɩ.F=dFG;T\@̌XE~g3hx SkkSo~ÿ{!*ۋpT&1MjB"?q6 EDoƵ^ |o|4`N\tEdҀ.I;c;.3 C<ҥKav&C T ԃ4/ U)蕘6袑ۦݡ8~ŲϳUrfҨBMΠlXejj }}}~ܹDtTX(h8fM.ī,B Ϥ^T"VY"$F]~"+Dj I[Nteu>\|Sרsb\Tޭv?uJPmS%EP;~~GJ.yx",ːzpiI؜ҋ Pu^R'Yo^xᦛnb]e˖C+r7Rfi@?M7l8t]C4 :&@\fȲFT=AY/6pVqT_ul5ߝuc0*Fb?}Qoɒ%eJxz9Ҡ#KR)> l}xm$!ivZbsM7҈hҥ #Xu 7.}_ew!]s5_q^o#8q S5X,wJ}"&Գ4kU%""@Y /d9HL;0zr\ccc*|dR喖ژfe$IkX  j#'c}{l6Jag(@ !zUWAcKu`ױDJip2W|;ōsM=L8(UFl7bV.jhkL\Nϳ"of `,XpYg144El!-t]O& Da`I섋BH/2kd2a?iH_a~PUR套^BKUW^yTxP(s /V0oȾ8$Iz/_8(+o~>ϲ^x[nXI Ň'+ndlw?UfZzE{"e,U\è4iڂ .?o[*׿N0686`ֆ&t֦C YTTɝmztE&pT (~tw o 8Y|y\85ME0 Wm ?mӴ6J~C]{\pA,kkk¤ cW:@QMRC- w1VL؈I9UW3)\W|{Wq{1gvIЭi.8mL.;[̀ NyiӇ8c( \vl9ɌR-Ȃ :K321m"Ng6*b)@D R\iWn*˵ΠXzS%w .2DBA[o֭ۻw/i&yƟX -t^. D|G޶7  `${G֬YÆO?MDz-S B4\vCBQq~#OD"͂(- rE0.LQ{U%H9"vT'8:՗H+T[#˅E_G^Df*y-_k*M^<UI| g2)ѱ DF-{8JNybȄyY w_ns^}$/ߝ&2T25f42cjV\"BI@{l:f~HB$iϞ=wygY8cŲ "HQ'|!$D(aUV\bŊ+Wn8p`ժUYAj0 G;8ehL<$I,0abGNQl-emXV4(<:X%ˆ#DuUpx .jE;Q Pď޲e ;6o,9S%V=dTAbM+>-9m*V?lz'"㪪B!UUA(} J䢜?LbtʶYn YȄ_P_[;_~ݢesNWH` +(k_嫼iP%&OGXId5,^tfW&Ϟo\TA_q.MvbEI$f`x}PD9 ;PR-(3Ȉڿ?UpxL)҇Zjv"]v2#N&fn]hہFJcr- 6PXi{4Uu3`KHl7ԲʯW>ZP h(h;͛s۶mI۶m۾}{uI˔iHGtGȨKn=0N;e0%Ia0|m)6*Vbpٶ|w۶mc6QZR%w9FtwN 'xGU`0V轚 o+Ee+BmxP^sd e'pbN|JEac}bt U%wO S-w1`ܝ[aIySg*3MoUUU/5ęPM%XuXUٳd,oWZ{Oٳݵkƍ%Iڲe˃><֭[#IՓyo~=*i+R>NS)թX%`Le,GJV#ٶ%POLU+=*^{WycoT$G՞GEDҶ,رczkCCC(r\"iƵn9Dj U;'"2.yGW^-RwMD6l`7Ddb|B_Fy{%Gsc#_FN{?n6;9/ٸ HxPW_}y睇`0JdYuó^aL&ɰƫSee;˸"^?`"8qW ԉ8qJx89]m=Md継eC#?[zc5 րLBW_}eYt0,hrE#UԌ0q*|8פu,ApaϱV:'$?fU(QVVrfڊ7삓\Pq[c K:kQŠ%G)\ 45=@Omns[|r[-vtt-JN&'&X[VÅbtNab027U8˅^YJ>qLUrU&o[fUr'!":;ܰaC(WRe*zl/^"VX @Pn87"Xz+sӶm!0kUɫ7 [Ur*;7 \.lٲ/,p6b/Qz)d3t*OW[>ӁV\iYցV^Fvرi&i˖-jl_LnUN³V|eAҨU%Ci^2@p@vI|>w$XVWlq#i[EȄsZ ؿ_ٹs ƍaB=C H$ t1R_EbWy㣾WDJc3S`JyF~_ў={8"e8ΆONdr1Z-Jug6B]+ڈHQ4s $oy5u2:tļ(1_7l@D֭'3&pvQU+B\ܕ*O/J>ƀJl!w'|6P"8XirTU /URTaOHW<õk"o8j[5,˂|8֭[x=x 7>/S*foU%w *LAj5کej\;U,J=W*10V,j UJf>84M7( "FNZqn+;*qy$$I{p)0 IDATac"z`lf#LbYJӎ*~ݮ*y-C>N#`EIKNJޜmժUgrTE]I7nܹs'.|UzYaB=:U'1̙\U3䶣ƤJR%Kټy3dڂg!J}b$Z`ո9hrzP,JI(vuw;رP/CDU+IoddB~n>~6 ljS( _WBfC,-:E86]p.6ȥr`'"T.$ǽ"qnSTq_6߰V箂q Tyۢ5 S#%Yc lNJ;{-fe vm.  #x0c=\#nUR6*G,l8FP6m5Ne2UU#H?J d@ vL>DR)č,FÊḶN6e..VDtȲt)k%ܭ͡'+Fʚ3K\Bd|o*|A-ӦJzCVmET܏ C'+I֭[-b$@+Tm, Q9O6Fh$ Xf*yqym?䳯է*9;󵷷_xW\q}ݷi&aeE;Zb1\(]} IJ;vXƎ;~`#-E`+ۀ"޲}v*mʊlCiVv5MXm>YKJU%wd~lso,m8u +4>^]J*D[v-6_x]ğƍ_6oތC6 L2NI$݉lP%w!jJ~fqW|RVu]IنRmȶu"8 ݻ+8pk*4yͺU*籚M**p34-NNE1R{^UUUUdDa|*RΜ$1U뮻pT uVgrUY!&iBaW6׽So^>W|WJrdvB)UTI^=J˲+*3H|\w}brU朗ێ*$I`pܹ˗/-[+ IQ2 P(@B؇lN#-2EFC>,={lذA\*x_'g m١nuOM.`8Cojj[Evg*@EK ~?6rNU!gf;NKsx˺ alJ摳=pu6U͝Vwu8]8 N 'Ɠ+|5Y</qk2\st9.8$a F%MU%]r"s Ƒ]6=c+u[cbsLuNϫqO?rGT%$IUU۷oٲv=$7JxOek:?|ժU"Dѯ~u{[!3Uh֣66pzXQI"_ WX88Tޝ 'zW:Vu4n*gw WyJﬤ]M%(kǯ]]]|^/f,{;wy FdG j+2MΥ#<%gݻwÆ 69%">??On۶uhuuV2Xِ4"EwUq0)5nuy>ݍ[7LɓIR&Vgrycw}}8b G};Ѫj f͡RP(U(/~ UUEDTi\.dٟ0<QSwXB!#8Ϗ֫*1 J'E<Ť,K*e8ND[z^ߔ%}Q9M+T.c``P(~\f{bڲc{ժUιt͚5 `tNeם;wn6m郂l q8 z۷oߺu+׬Y?1Do?\.'qJΐJeJhcE*74ꘊ*Mr^)Uj_־tM&8WGksL b1Vq7W8$llqDlxV٪clذawu=2!cNCy%IںuuNrlAVpQe7lijx7q}?O M,\Y\;-[ ׯg)#\ J-`P(FBF-[Ȳ,˺;@L&4MCotj &Do]9W詽&lnꮳvUK/V"ǽmSaUybN{;|v8dYd2<#s6x,bN!RŭW%^EoZTe@`YCrJ(]S"Ai0(B<BM,nShq~huJ>\%rxjqWlpvgem6عe`i/+ cR1MsǎՂ{A "t"Ht_LRt:͂:X BHp8D"H$B`0(5~xovIlOwy,0HP%ljTUݳgիQ{ڵk磏>-˖-+ \wʲW_}[V&wOn:x^"bj_YK,N t*a>)jN jrK.kzT s41w-HAYI 2EuD=\# rni0D4ML~I^/;~d#,9޸zn4>m}m ht: ʕi]v6J¯3(ڎb=MP(W y5w :%2 [s,WmnsD85440!l$*1Aj%w l69BN޹U,4/𠷷|PK)y'477GQ|$!](K|u6 <{l@i)WL0Lm b Y1 ׎cQ(a؍+|p8D^ap>=U4KA1颅5Z-1 J>m3tE) ~8ﾟ?[o۶m*8b1,+WqLcFZJ4#u]m׹xb-ñXQUU Y_{InݺU|e\4q&tӟSg{{{(躞L&4D.?~⨶h4jF2|ᇳ,h$;5M۾}ƍbKzU%/9nKU U$w+`8*]RڨYm#yhY zAU@  DF'M<Ol){( OeYx9s@X=NvǓfACc=vw[~z6}{|LBn)fqeBT*N`0LRuJ^k8n5ne c KZgFW/[W|VIf0ag=o8r ,cF6=w3}'Z! *dC?|z;::EO5q=CCCaoe,˺曟}[n){6IƦM@Jp3 B65 UɫZ3$oiRCU%Ů<aW_}o[l{T@v#U~\ll|"%|?mvA˲|:NRg}iP(wy0uOoDQY}˗#_o*sBO$d'H^o6FJ>6*H>RF hOD5$TV'ze9;eu8]UODUS1/{ޫ=#-]^_*W !1 J,XyTD!ZUVIr ?!i飏>/Qwy7.Y&*6588zgggcccPO---X̲'OF"0ܹs)mmSkOl -RK.<T~P($aXܼ׋@M@ɤ>J]{\.N !a8C+͂;pyx8ZzrFp. ȝ (>o޼Y(i:rHgggKKK*;]m=MW:YMuzzzTUC >:'D" djhhHӰi,gp8 "37`u xrw\*0 B!z<|P|b|H B;v,ɘ;::D2liirx<}d2H$h4绻5MzGJPO?|P`0d\pr ]Pwv4T0qHQ8袋$IQ|D".R)˲"H(TTUi+r^037Bnkk+ ݲuomxxx``@QH`I@Q4Ir.Tr,-sKʢ{<ollIbi.8mns$4 r~90} X>"%2id|T }W8(js}BK@tN?Á:xLoQ: 8Yj\ɓtd2z[[[O ֧*9-wn}U x'լ<|LnL{OūwUɫ? \Ν;=֬YoK,yx0iB0~,˅B!A۽{7X}GNF{J4tǽخ+ ]veDH$f2.100`;<$IF&B xhhAf2`0>}]W>G 2h4驺6XIأh| 4&+*+q?dA\_} "d/!E1cm7xxw/"eΑ )L&'6qXx#%KQ___,ïr\2TU5`CCXf6[9ߖԏlݩ /|*k|S.j %Ո|i3 }'OlhhW,%IS?r51\UZE Ԇ` s&˽^/WZ`@gO@&EQ6l ϊL7YEQy"z饗#0ꫯQK.edL& B4ESww 7-袋ZZZ}hÄBЋ՘|^QF6@WĮźUNy֭r|8VKeNa0J>qUrn }݇_7n888LP([.>0Jp$A(Mfvs@ߪ:T!xVXqn\[t)z_+yK&aQ:ͻ?nܸ9"׾un߿"Iz`?]A"W655A<ԅ*y-l~.ɮ~VUF]-g2 s̡Rmkkk[[===CCCPnhhhll*= +A]NyW=E-xDfxRUCh޼y`P(o 4MCCCd>P @h4Fd<YJřOd1oׯI'$g}$(P@ p뮻.پ};ٳQqp 0Ν;o޼s644Q6mkkkjjJ&@I\PUU H$zg*`вϳ K.+NcL­O^%%2j\ B*dkmmeѰTUMRCJU!JP.h4zaϵkz<;wnJD\%U=??яXCKM7qط~[.]c=rJyTJD?sUUmooWxW_^#GN8C1`[j`Sn:)}Ⱥ}l( ;x뮻7|eY^hg}JO|(Aᚚ]Q /kA%Ydj&Ɛ؊_r?報D؃ȴp8 e(JRGvTnhhhoo7M>kjjfxʲ@ ypTrۤ84OwJu47!`(Qww7M;;;!a+.9seyVYT$,]^bp@F–E w t g+tuu)rIM<O6mooGzСC\p9s~""m\냸6i,s\[[[oo@"zeYSSSӭB!f2D"(J8488L&ɤeYp8P[%_%WeYԲ,Fs΅$+l/tz#Ø,?0, b1D@6z@$x< 0wHmnsO|{x$ʼjF=OGGҥKatuuYǑHɲ<00p1"jmmM$@`ѢE "O@lc#_:fr PMRa&>q!;644'|bFÇBмy(Q(D"H.b`uJ>:M,mczՎiN3ӟGN*pxbkiiA&CχJ|>dJiO`w}?P @e=C[l+gBAy~va[n0 >p 0_~{/xS7oB__aX,`sYge2|>Ovl,x~_nٲe޽{׭[ts&P` -S8޷o߭ ==EQ^z~D"NRD"ۋD/}KT*q ]ϟN2G}W(RE]r$DKTw[պTo3.9 iV%!AYC:,X I?CyLӌb$Cܹs#H&b$T0Ms޽7nt Ν; C |`0 aܤR!]?&Pj= B'Np\XG]q,#JEHiQ׋*=׃ęg 2L!dvuu;hp탃l/ Q8f \.vZxl<2޽vx&:ׯ_/"\g^:Ol?], jDQلav4'/{o"0" K\H4>O0k[^\ 缀SUu랎 }ѴiƏx / ,~~w t|wu02NٳgC_44c^gAOȍ س$dLvޖs?g4تf u]cP$+NPx<F(ɓ'`4E.` p8DGɨ(l|cc#FcE*؂[8vX[dAB@ EA-b1(S݇S'I-rUo7΃#s<tF#  R E9>GrB^SSY*b1b>v??>}ݷzO>9u, ޴B# (p@3e٭[҅Оt窫;pA\pرco=j(^">4n7kJEb+( :Ev>; Ur1}1#y.y2*X,Š5Qd-[,Zhcƌ̙3D~4#{7JLj-X?PDLޤd2/⋌W_} 6D!@ReMMM$^!U*y\A&U }6C΍R,z,BmȚQP/UKJnq"3g_@H$rSN*t}[~}"hmm7nܸ1N1'۶m[v-yxbmذDh"pgϞK%W eժU|HB_ dmU =m0$ BAﾋF3@*H;r]uU8bN$MVAB_|t { hBֳp \~ QNp¯"貝o j$ yjۍ},z|?})pCRaHG0P, SCgx߯(Pa N&r@p(iRM&p<6RΖs8 yC{𵎳7XHdLnHTf`'򗿄9 㤅Pd!s[lVo߾vZ:oss3g鑃'D<#q˖-֭#"`vf_9̈|s+Bp(l\Y1J2T~ّͦ&W* yʔ)3gdm޼&3J(A(J!l$~SU`pfX~1et _Ig;&j/_|fٝ;wB fΝk֬1y, R%/K;xoD0O1{*p0T( G}t˖-|%0yR;7VӴ-Bñ}vFVln-[wM6mܸQ3XEUV]%a؜va_B9h!gxLJ;oG,K6R^D¹rzl<#y=^Jn!~pvTr>ZTlB !>7n…nv>Z DUVZ pg^&׼"Ts1ssf D").fR%G~ZB`o &:_[ݬKn S"(?# oB1Ⓜ iڊ+Ezî[oHT7/O+w ZcR"`uv|ĀGdpdzGyټyMP$wЏ S38Z[[ 9 *>tV/2pLR oHu\6mzGćPO R2ƍ6lظq#N?0 u5Oj6u;Vo3ѥdnD;Jf;l$+WT.R%WUKhk֬0Ǒ,*t:kjjr86oo\nD@Pp˖-D~PЅD(B# xK8҂˗/ǯpfA5,e;V҆wlT*u7G?Bu"#D,x<- C1 ‘+~PYa7,Bmfyް6;&l٤~l#iNcQT?g?,&BxV3T&D_%8&lˁL|fEZƧaQ~.)teX}vR AO|[c<>!hv:Al&[ 0t:SEyTrg,&p-xzO; n4MUc i kFD`c8KU2SعzPp8pKM# 6@ו?˦MxcuT͝sy((we˖aݻwoWZ@b\IC>$f*Bp _cVg::̤~}pT%۝w9uH$m6'ޮb6H.fv H$֬Y×NyfGɇǛ^qYJŸBۺu+ZZZ-{Yt))_k[oJ^l6Ƌ)U.KUpx^ؿoX? }ӃB;&ņ !'(|$+N>;wܹy\ Lv킗iXdeQ( U z=5ctI09 ]'d Mrf,<"6a<6,W*f S9*ZIEdN+WliiY|9jʕDjnn^z5ئݻw/]|z[laE.;d z@|^Q2Tɇbq+Z1_^ÕvnET*~){Ψ[v-"'-TY@ uƩhҥK)HfHHYlY[[>XILfz+"T[.>BwիDό^+W6޻o߾%K]Gc6@Y> 4|T[#ye*/ɉ~r'xOOONk TA#g۾}; WN%)q5L;&={(w={Tjkks8v2D2 -BDUsN\% &_>XWRTWWW6~UÐ @ 9o N&tZP6E)OKKKSSՔ"|۷-[lҥK,Yd cl13%ҧkV)Y?%8~Z}ھxOĤ~y)`IG\#&>g2h9X,&T=G٬2U B)ސZr%6677755A@wFN3ݻwŊ<hOZ BM9dM-5̼>/]uU7tQٹj8!xPJ#L1#gw cNhtPLj~`r\p~4ępivAr #Mj6^aqLF;u ^twwWWWczHv̓D\d2rTU FԳmJR_x J񲳊y8&.B7hO-ir&l;9 3fQ=[Gry3K" Q.r&l0G''Nh*iS&GdEYbh) 6E_WuYflfe||IcTZf\k|P~{h83 SUrÑL&ڵki &tK?Bv4P'%YpJ}t}`5551.mc׮]t@>XVѪR+2+ېLRk䈬 C(X엿%HM5+kO7oްae˖u֭[(մQVZ( KP&ڽ{7Oڵ8L3J^27" l,i$VQk!T%U46CeŊ_y8m!2-Y7pݺuy%2ށf4}Er;h~9䲕p~pBۺfQg% pfn(񼞵T%gR% ]vc_}!'pfmޖx?^Ω+iΝz@JhO<H4 |"'35p{8ޮwԚB(2{pf Sپ؁. dGԺ IDAT2U*0r ol%!Rѵl9TɅ:}tMM (-iXЊVup8 5#UUx<}ǎ.>:thժU555L&b1 P1009^/:T\!ū9Čz?2i)*le[ЋT )l$Kd˩nMRb+&v:`0p8VLfǎ+WLRd2b1RЕH$c*tmmmmmm` 9Q)\ʴ[ز%A6_O [Mdʯn=,_vu2ꊯo-yO63F ɥQ֭(ƍ)iDUKR_ I$]v-Y$=0ebXoooggg:Ocwx+j:D"+Vd2ŋEkk+ImmmDY#.DWѪ(I$A`0Y#nq"f#%}EvSX"**IUrS=뮻kE);NߟL&3KӱXLUD"ND2t8؟6w\Mӎ92{'OvvvaI 'Ok뫫^/z2`KT.Oپ}ڵkSl/]pT\CX2.gmJm- W [ p 3TxCC~K.`08,'bD"x Y4M?p8z;::RT:v\~*~ t`:zӉp+O1OMߺ"2Wx/ .|%I`vc <{`q8@2E&LǏ5jx” S 1m.9n(rJ^ɡ#<{tH[㚦P(TSS @Cmjj x=6wFc EQkg&fm۶7>o߾c4mס%p8\/\aoNSZ1S%';XmR][+cYBy=M;dM TpO)6;>t:i_~eGGDž^W6$ ܂@zz.&{lڵ^1F8%V^ܼfK |Nׯߺu+:8Q;dxH_S {f_W ׫2/tǕ/o Cޡ5+G\ n7`ai? z9H$d!\.ϷhѢ_~G?C0$ˑ;v(EJD $?asv Tif=\pϲu)_T-g1]T*9O @R-d?/z 69OLzկar\k֬I$X,L=z7x@/  S\vHUѪUs)EvPnP_§HJX i"VO |{NRU 97)BD ()d:޼y I&;w5Z(Jkk+dX8 p<AJn'!$ n= Y*9]~F{V P_G5A,kQ&-kCL뼡]GS9'`m\p8v13]i@ m۶ 6D؃Dl:noo7ox<"܌\Ɩ)ZZZ.]pn"͠rGqǿqd#:U w.՞ޱ|sf)DRz|\ ̶@ቬ9_.U퟈: J 1cTUU)Syx z1CP,biQ/ x|>b'ԋ9ig\VwJ\Xɤ*[$ NJnv}pP%'ta7<O2Tɓ[$7o޸q#Ŋ*o.\fh"xi+|>kG54M{wc]wbN!*Cs8xMMMݻQ| O;ūqUuz'J. *M`5P@HT%z6m3E*yGGǖ-[~ӟ2ƾ>MH$p'J{t:d2^n_؇~/w}qĉǏ~'==={Y`fҥO=Uhll$|-i1bʩWD1zPI6NR2K膲`N^ϙs%!W%46iW6CJnրICUUN>}ɓ'^: رS'~?aX 9q8c>~e|D DKyf_WѣGp%+p"566\g1 TJQ%?JeXKUrJnJn`dJ|>__~9~x uuu}׈9bH- X__z]vQJ x<u OSK;T*yi)F;NÕv^*Yx_4o &BP"*s*H'NT*j2UUuppyp)*lItptuu}駣F5jTmmm2 jkk/"dvvv|(D`@55 $=6@4AX"z'´?(ċ-u N&lNaW_}0jԨp8:V}ݩT zl e 05<s=;w.W!RT1XN *)Wqr*Sr^RC#fA6Um"4d?pھ};mn;L;? yގ DPM7c, ÇoH$RSSU ygΝiڑ#G~qA8p`Ac- U|WvvJ8HPf1!JnDc_|EWWo#GA|F@$v(Z>|732=.g7ofΜ9<jVF_oZ6I X볓Cָ. 'NdTP$"JUQ%o>7Dfu4\.W0kuuu555WnXlر|zuuuce%O>IЩM+ k1ƞ ua .iC!A?҆V*y^! UPILܾ/_$Z,9Jp̗Eo{V1J3xf h) lzӧo&>r-1k֬_~{aW<(9h";ɗtoWE$a]my_yӋKt_&U휽f'S9\v===}QMMW\vCy/7oc5\srM>Ab op 1UU|;> Nz.Z*B|0\YD=R'ŰxprHUrCU(gRT__g};X8bHk„ P*,Iž|-lSclg&nat3zI|!땣PdQ)P<28\5A';'Vڜ^Gy?}DZ .:qć~HEz{{3;＃"LU3nw0{ｗN<~HVUU1BP(""g%VB@&6R)BUV Rlm~-I$/r,}!C~v!BD rh4zرO>1V__?q.16v@ p8>éSH$3>*xn-;=3~>9rdΜ9谀L`9ѥ\)W/SpN7c3 OY`L)EKRT'&q*(%چ xKK >tww#w߽ F{=-vN'$͛ǫ?:th…PG!zAZ.]tuI~N6֪*0wN49 JӉDꫯ1 zzzn7bcXwwwuu5 F`0NQ0 z^x WR)i&x=h l&91}GJIp* ? oh4 g̘Q__PcR%LFp8h4p8H|>;[ A;# E lV &zFBViςth9d2y̙O?4͢,)(RUU8 DQY TmC$č! +~ C B2'd+! 3xYbǏWeј1rn2AfƼ M8E"@U#[J8ZCONFbE¹T賀a?$VW*)s( vuu}Ǐ߷o# v!\.-_q׮]ظd|/޽{-[F5M۹s'vnjj"\C [ wF ےV4P!-xf8TM \D"ʁ@c߾}k֬ Hݺu `Ey<˅x[,Xjm嚦޽{1Ts%1. dZr%! x]5syK&wY'_< Xc^3 *I$:H:_|E<','(A7شic :E7O[F{aQVZųvd$"žddЪ[dGl&CλMlX~,x^Ǵ9љdv&>J^0YbHN'TN<ŜN'E/~׿5~Zֶl2l6KA7 np %2``14~9Tżem/`> -E?`)"Vۮ16<Rx}" TUŌL "XSF~"M~xЈNDf@n 7XYS9{r֖mxH!P_8W,!pN{+)ExyY92 4MC EQTU$d҈+ G $: YQK:q#38{6$۰'n-&5߂r O N|2?/4 SmmE]4~xFzzzNgMMM p\p)@*{Iӊ 8\(CmVl*J$!eJ㜆I2pe(SXl$8Y;?J;( L &5 HL&bxDn=I+VP_d' xH?ХQ-E&'*wr,Ylұ')G?bKX,7|wxH&Lf̘1'NǜH$ଣtt:NmcA Jg9PGh62GD?].P4[fXlb˲GJַUi꧜`Gz]uUUUUN BM?+x @ƞ/wMx /й.c/,s֬Y3f ЅM?:z7lBPaJ 9UWvEdmX* x;OO1T%PTqa !"bx;v}ٳz2D,lpioDK/8?w_;_'޽( /0k,vm} 9s](sۂgNpU+(/KN9֡tBZTNi< )] '%VD\pwF"L(oEo?;Dցm1/yـ&Y=蚴?|x7gΜzQߞ6mQ<Ϸ?(EӖbmY (227|U9M5\idf^^ɧN{?2t(~;~Yrz s#`Ua0cMĜx5\N u#!Wq qh&#I<J^D,Ͱg6l  ; okfww?H/yJגsZ m7i6y+1vԩl6z 3,>O?4tΛ7rfϞ c{}TYDCiګzM7 I$#d2 XRj_Eo6IG_/ͷkyZDr[BUr} 0p4mLW]uե^:z^IWWWuu5UXD-$QΜ9sH4$4 Nw\sAH(# =ndB;?|d2Jgd2^36Y~O-t/EQs9k K3z}~|p31~kOCk(5ޛ_rlXHzxhÌ1wWO6;1ƐEzKR )NK@x NBBnȑ#0ۂ t:l6{a\.}ꩧbX2$:"N_D8MQ^{3^{^{ JG/ 27cyQdu9GE/d49#3n8D)Uf)`ta3Yy ~*#x[Oo1OUU.򫯾N*JP%[oAālK֏dhOΝ;v>r_9 |ۧ~# ^xu^Yf~v1c`H!"T*yS\Å9eJ- :dz̄#LJ N{F!eCs l'//kR%2 Sxo.;Çϟ?'w}0hh#0w|&o9WQ %O 3Ev Nfu9$É$ z2=1 xBnK/+c]]]p8 bf"`~h&Dڬ$ˌ? 8"*p$dM6*ޫFn^N<+4X0,'2cƛ݃BmqƌrL.bN~+/t.nxn_;pv|*BaY!cII(!O>!a3+*Pj4?l8v8\rE]TSSv޼y<mƌ|[o9r 5і'|r…atA-Z7b-c566R%C('D!{ｗ Jqd'\Ъ=,\͍ %ħY+*1 $gY8rppf(*9cT*% g̘t:W@E*X (2k,W_z=NC{{;bW`Oo-}NTew:Cȑ#~}dK3gF_9NC{2T*yI}RTSpYJ&)eiFƯZ/` ^8qwk$NMHxxH>pRvjoo_`0cO<2|b޼yt~u$T1N4HʖS莏T}e[97ɋ;z B7},j308cac&'qX#`]UXj ƍDM:)Ia K.%; ;,^ U? Q,X .͙3Oϛ7H s3Ib/^,$|3J SG1d2|&`4%0ACQ! { ҃_;'⌓yTTȑ#?rz0@CosE?K$@9OHD ˃16vX6POpAn\@!C/fNХ$讚z n )СC|#G̙3GOGޖu9GIr<"kh]QE>R=)Jn'(@1 *LИ ׋#`&<;*Eږ-[Fkkkc{ٲe---iڢEHFxim`i&n[NqJ>ʥ32c>=~uO9X[n4iҘcT7H$p8ݝH$0¼zP( UWWnKNB$-*z`8Z>/06%i 7˅V<8B~m'wdUMCE]4vL&t:x"8y$q t<fT*٩qꪫdF!x4\yrv|l>ɇ1ge^$8%m#I6 *+a$9&Lpp9s*h8'$)|:N+Nܦ3 )?-em0d (RU5dh*>Pr̰v#p:;;$9_U3f[KKʕ+yժU<ڵi˖-mٲe{YQ%/D𡽽Ez $8'_%XYr;3Ъ CJ4%<+È}:VO䆏 ,k*5"|>|:u*1':c$F2>}̙3a{4䵏ϱ!j>WЫe MvkkkwNJS AOF6?~* !kHp΃KPzBfo3XЇ٤pf="_yrTs:PZUy# *Gb@4 BPhܹ`Q>}zuuɓc_:?~g&|]vYCCIO>oɧ)2qK/TM[\Q6mnnf| 0IDAT⢖/_1A[p!JGzSpB0G(;Q d+1FP8Páj<5jT8BlFNg*OE0ag}J.+cl̘1]vF vǏ\Q L0+ЇxV`s UyA&#;W0ݜ )bGz|l :xK~3yf?/f8ky@/Hx藏 l@٬'dM6IOWcO"׋Zp#R__W|3`]y\.BK g ڲz4K`>:(ȗF NG]ink;ɷ3YV9Y'<'%Z8 8l^?b jY!pT%_I9I\aDA-{o:~g׭[7zP((c=/ =zɓ'1c@ A8Ԏ;֬Y#lܾ}ڵk}?Thy܅,p˗ho&-]48p@bQT078|s"I!/%o[a@ӥ~_2ۚI܇wP0z{엿%"Cp瞻[@vcO$FL(-8i$C=_WO7n"Ta 8xzd_D;vXnzؕ+W 1Ko߾F{h"(='$&EȕjWlNJ[ٙbW}(^=_92ܜ|}+s*j$<(@1f(P4A"ͪzN21{ĉH$2vؓ'Ov+G cN;w\z$xTfHf3<Ow\~S1ap8RlUJ^I0fNڰYOT谘*6҄4|% @b"Tl ᜏ0vf)3f8#nے$q˫1o: %zdn^h`IW~dz'.\?yNd!guq;&˜l7<$UU^Q 4\Y$7d-?Tݎ i?ō"~-[5c=G'|_̙C浵ݧN_}n۶ _xK2ᘫV9Qkkk؈$\L 'RW_{iV1m B'֖S1 Ib=kT>^E.;3"PVtmm-~qF?f̘Aa`0UhѢH$X*ק*)'a*Bi';^ƵkRj[nRGʻ˖-OȐ]p!%3Qŋ ̙s)Xu$kaajTZ c ^? -ͦ|HwIFcY<##enlEbgʕ===c`Q"2:::`4 Ì18 a͸\.$EA `G,vڼjLMMMMC*BB> =ʷE|&q{9 5H7jV(} [<rER d(-M  Lݽ+6 |L&>ǿH]EZ>EyMM ̅X,(P|yOh<ߏ8ѻ{n!G6M@MNlooz  çԵe?@sM3i^|.@"kuxJar"SPM*yBclE%b1=CɍrvV :R3f7n\  )eYn۶ Ȥ_l6S*}.R+u߾}7s#P%fAR#n3oOUVt-DzJiq~3$\3--l0PlaN߸aÆd2Of͚8qbss~+ӉҦMnG \`/=iҤ'NAjvԩ555v̼xz$l|P+_z5![ [x1`%gy 2W;w\ȑ#G`}Ata,$7Nh4Pg(P((f~\?~8yK8(U̙3׿2Luuu0/^|ŗ\r (dȃ`x;>%Rh4H$rB!fb&E|0SnP[4S+^ƱDjSKeo Ӄ`]VUU5m"^ @`fJ,.+ h4JA#HUUө޻fO@7 wR)z<Ûg2 e/!AE6Οeh DKPwDv '{:N1ec"zH1N1c6p#@U#瞆.|<7:L[hsD\yp%sO=?5!e+r&LD"ǻL&,%Q<yOW&aO>MgAnM$h5lD^5]A}Ѧ rYN(NX%Fm em_eX98&lUxT3~Rճn'GUUrfnECci{ytQAvbp}su|wQAv;\M/_}u xT~IQs-%98x;;*꒳oʷ 78 }r)/pw|AG&&G?я|dq~K׽5~wWU4%o=ellT*?׾ſ׿ xV+c(}K_z5l۶g>Sɫ_kggg;ӟo_{ɉ˿q߾ǎu/x[KtmJ`$W]uՇ>AK?uo~W++_뮻n=7_y{}9pjsCn=_u4 z$ލӟ?C˲:߭=9l9m۶}k4?}ƫm9r$_}{oEz/+rܷ3J};]z^o~]}K.?|.GmiuWt7?;w?@%\g?{رt:w{ߍ77]z\KwWU]viN|w}7 +?d7]w'?C}Cf]w/ƷS#G;/Fg=K)u oy˟9r]> }_"]?[NR3[O cxW;ɿ/z_ݷpz~x||k_~[N:Z;[yE/z[wVF -o ~r9G{ o|㗿qDajr~g\7wAҾ򕯔v]30+'{M7#G #G>_7q-d2緼-g?Z7ԧ;l3̭z[=J}zo?~qT*vwqڤz*8sV ݭޭѰG'— rn=hcʱG3c><66xfg+5~7o>y%_>z/=mئcmv`$x"cǎnZ[D-ګЏ_epw3AF.d/ ۶m f2wu˭v}o'??w|559j4B5=p:Ipg^[Le9_:b_z=p…E,l w"Zt uyNM:-aY5-0{S. ?R۶mcOo ".."v.#cmo}kTj }vyӣ&mos3 l[G[st|qrNuKwOپ}K_[>itG_ۿ[?^~}_mo{?y"ow6vpj 柾{=عs^ʛo<+>ϵz;q뭷?mw|_p{}/| n vNsh4"Sjrrtwߍ7|>발~<+^o?n-huRG E-?h4};ߙJ27]wJU۟/z q眯0("Dӟ>qp7lv]Jl<}3]Ȳr3,+g#,-#o|#$g #y*tw6,&+d19OVnmb^^^^^^^^^^^^^^^^^^^镧`o zi,f%?XEv_okomXfٟ^5Wbc:@, Rwtvf Wz֛^^^YN+l,e%t\\ed>bMku=3Wz+NdpucR>eo ~GwK0}5JWz&ђeUj$$ay975謕JzWTE9aQYE֧Wc鎞~GJz!!Fq|`߱my}& tLgPet+u^cBк1V  ~=}m}: n˲ځsQnfj+;/UsJ9W|YtZ|1$PJKSJ)"H^}۶m4vBDDh4FCẮp1V.+RbcL&#]/˵ZͶRyeY1cL$I&U*BP*R {+eQ+htK;9Zˢ5 zˋ󖗳QڢrFu? D 6 u:NT*EH$BA˲օBappPk>l¡P($R6zNu8B!9ST*"a۶}'Xwu]!DXZ'd2ŪjѨT*$ܶm۶-{iEۭ=XΓR^]Ӷ펋l:v[f`ҎRբ5;,l랍niݰQ|ܮ۴Zfo[rZ먼ֹ]~'19g!R|>O鉉 5cu]qlr]T*@ZfjsN"6Os FFFJ2;;yy 祔[nu]7JbRzRF^yzB@Eii{g8g\nt˖6gbtYa64o<)eYxy,0nݺujjĉ\N)d,zYN+b?m`{fjqyX~?YZzXaLԑ&֚,:pXaYV&y'RYTb $roQJD"PJ޽/޿O{eUZ9Ms` T*ڱcG<b8??O=.Zj_ŠZ,yrY`3z7cy6YqZ,=+ëj'jV3H}@ wפoʫR{  Z ('<͠@ _CS4 !RmۅB! !mRfsss;wW˲"T0%B<xZNLLpwؑH$?33F?|u6|>.mH$Nֹ\.ˑѶd2Ib(URvE{7{-֙_tWs,U;VL~閼qXd "qՒ ѮIN4lXZwHk.ZmQR_>hwcv s^dP(TV ܔ7*رc׮]tѣPHkMH$bt R)yZ^lZkT[(M~)c?<33C9BЁ" cB>xDLRt;Bfgg)!ֺT*uEɩI"k u~QL>+JȠe_jEw x}eQtw:drϞ=H|tzPsNffff* qRAjZPJ%ݻwʼnL&st:=???11A#GbѣL&:bHD)d;F Qb-.V&Vi,Ztۺ=sYGbQ,ri Nxl6\kBv8DMK (؁>|xnnζl6;00@a*iYV.bLʀWT% FU*X,fٺuk\ڼys*RJiBcǎqƈ@'8#cԩSrYÖl6h4r%\.$SX ?xR ôo@.phVk4۶m<{#C"d>رcXWWU+:\|%*x32~X Tފ1'u0g+I2mv_sHG~;\1 έo_Q@Li}c,˲mVQpRЫV"NyXA`jd2I),;q8Zkbӑ'2|CCCG-JB۷!S̲;O)511AiTJӜjZ.ib>K&]vَ;HȣGMH"k,#K׹2/`tVlo¹КrO 0 6J!F"s-)4pWD-!%cCP@/t( |õV Ȅ9J+0&!c LKaKf!0z'?skhM+bQpJ B IDAT$8Z vE%gN{'K߲l5\IF# "m7DXs f5Zd QC c1D)%"CdѦ1Bf93FӣZ\1@P(b `O*ИAi9F0 }_j+q"΂#܁lEY?X|y(·hWyq«_,sa)XUIIp+  9!qJԌ 8Ҡ pu 411TJi8v0`R 0hH 5 1^dtV4+zQ-x0hX&djmP4RNOOy1 [&(2d\Xژ`3-w!8"&!C" lL3.R*LpKDȰƆ1&04AR /25h82~K g1&4Gys@CE9G68g1[f"- a;CjtSWtdu?;BG/v`%jÊVWmyKj*t S銕P LJ^FTT*eJ>sT*UUbمBF155E F 1+LAz2~``3>>~)qhR^J1m۶d2955ڲeK,|CCCJ~Öe ;88OÇINP2DW?rݤ-ZEr:3G#dZ yZ` CDmYhT*Aƌn.bP:' '̦f`$0Dm ul*tƀ56m{׊)H6i1DιTJ) Lk`5#Ķ- @$\PwOa2C^0!bi|_kנR 0\ "%D< FTRoƴ`y;Z& 40` pƥiu34B ƀ193hAm@ƅH1rF)5Cc \6a[H(fb(>eL[ qT8NXRJD"i&9yy'|rrrҶm!DZ,4h4RJJ@y B\&oYV|,m{;JF&Rn޼9LfY:\.K)h:&G<߼ysP \<~ggg7m422F8QgggJ$4jP(VӉ_I+3hڐ1fA}\3a0])6ĢͣhTiSN*mhEXknXh[ZQk94.XP-7iOGJ2QZS*%4` hyO%6]\aw0ZK {`}Ɛ!jвlmҊI3s1&8###X >=56sH  ch ŁA 5;m-cь @W 5Yk6d@k!4mJlgM a0J*c4iiEgsiIZ"l3H$2kȄJ&m` iRgϞx<\.wQuTQ/*P.'QJ='r2J%J2??oY"Ϗ$Z&ؼys4JrȑL&k׮."*HxW.s%50X8>%B4Z7]34T-,!!W2'E8ҌRT*Bn^/51*"93JkM&4*Iv0Z5 ił5Ak4&w g\4$9L*#%2zJr\TXs ɎC[ЂR1 5RY "=_yc5ނ ]r2迸LZu~~D8&Zjt:clӦMB!R<)6~{( _}pr4I!͖J%ڟT,gff*%wHRh8(Ŗ-[&&& ¦M;44yl6öm:z4fuhgq+r ~6@KYѶlƙ`\V&?pk[D1Ј`[VŕuDE d:mTR)Kdߑ$)c 1}y}_+MF"cp($}_0m[c1XoxZkdLu,H_IedBp76FJ%dLI-KXȹ1Ɨʗ4+CisBjc 渎%Fz^ii:q<\5V<,enZ{?;\2A0x KEQ3KQ%J8%(5uDG+rQ²,DAEx3;;[pZ%h$y}}}bsN~qj$17o޼e_Jp8LaəBd8y R_["O'Sh$ rl<bbR*9>1 LMFdf/-N  `h$LbqzsLVrlΗ(% X[Siy}6o4*{e')Ub8;eV#O E} FQYȀGyu_"S{x(Q,+ j5HKR2$>w>'įj.UD0ߺu+%""Kkvvvzzs}v YQ}?E"\.GK7;;{lrORV鬼Hd=;Gp644Dj5cHTR%`9J"FhW,"FVcC=@[I__rӦ!,!zu-cB!wll~Hc @9oq7h-ܵ_" VZ+c !4Df>Z*oؽ>>}ϽH4\(/2\apƍB`oeEx'yٹslix`rz._D<@dXV>ٻvȱ./, blJ\ǮF8Dm\6QPX;84ڶҲ-0^mvt;8l}3Iw qhp,dBH,.JI¶MÅ|!c )m8cFJXVct\8=ڶu\lҞ޻CRdZjݽu*;vˌs)S;AjrT.st\!; I)+ q(`V۲eˉ'CB"rBPp '"X'HR${H(@Zu>l6LoϞ=g"\$mL&3>>NC%ĉB822 (-@(cǚ嶣ΚX\Y.(:CV(?Yo(΀1'S 0m0;3W*?3j`>5dEy=N̙5#4-!XH 9~ndHe&箸9Zix<ϲ7T%|Ry)9{9?֎LĔRJ G@DbI˶+|PXQԤT8cZT: G1Rf3L8H$t@*f2R)ci"gxPssR9  Ch!XP:55?2<480n4n($3\InJIۏp/Fa]`W=]:LvpmXǟAlHOrR慁#G|p^S r|cx=a=D쿦i 8l-"1&|H}Hk=33300yl6;22r?/|!nYlP S;F*499IVD܉jU). ˕C2̭ͦkZijsK9CT*U(Y4+.j˝a"0Rҟ^r|$qV* h0ZTR+]*gfuOVJ aRRLA0`LT=NPVZƢIuY7 ӟ>gqdEsHDCb!q` -!Cc mZl_L6 Z r|Y<_*'MoNoMgwXy:0Z1d\v>U_b"AK>jb Bckeh4)*@s?/6(=??d|i굺㸮3 Jvq"LMMYNlc,͸A~r {虳nZ4~Lgv-C1J%tDB!̈F8Q0hGn)!BH$jQX`:_ѣwɓ')wHӛ6mJ&=P^B'xW*eq_bRUmKhl˲- cbTk36JJ⥥e1cL.7`tÓr41plm@ >A̿QΛ_4Rۇyv`GNy DٓH$;FW-˚FjHoD5"3 p(iK&SkMsHV \bPhtt1F֏m^xyO<ijɣG=ZҡT*j5O@D* eCuiwp.MĴKWJ8[/"G~A!t2@$F 8O|d1 f3Q<K )7xh;Ʋ,9CDBasb `(nFNRK1Za۶/-(q[E`!%6@ Az7x}?_ Kj-(>M,ږ(탯Ls$-!FΤҜ u`90J.yb)6Q۞:?d!1JcsU30A)Ӛ/+O*QKh46Dsdu1d( 00Zc\p)6 !nȗlmc5-Ciykڏhm^b8N\,+J:u*H8c0KĽn7]9qVz!1R"J)bRضN3 }E/zQ.s] .>tP2 rytt1?? Q%cGFFld2|{xqa8O^ųU I2j%L& !͙.Z'1wrbT!&Th(MAlƜBVV{f4H))A$hiHs2ͬ3! ZZrNQӲ49NAeAhCAf<Po}ޥJmL*>m55,"@D R6e8_*-|- HJtխ-T1"c̀JQ3bk?Va@dK44Q dJ1DP m(ks2D \R!hDZiŐRmM4B2VEǹxmu:U*۷qrpBM6Uh4J./:+6FIj5H\Ě (y<}u8FƘbHDH$2??8"RvݻwFA([yFBx}e]'NMvlL&X4bhlJ1`4Cf KiN˲@G@zN:hyOZBP!5<c  :+c" R)I]pe/l|˖'g¥c=抋~>1=׆L }hg_*:i+Ņj!>n|hh&ZX&㨵AZ hYJqBqT@f "oH!78NƀXhLpF1z3Q=mTZl޼2'PXfAb෠S+ "eK.QĕT*T* U*:K/=rȣ>k׮ .h=5e&!hml4+DchhD&NM*MɊ{ީ鱱-Z6 -[FSD"pX3====39 2|MF;ojm>GaI?vq3?; GD^E#~m̌m;h P,U*U`ٜeۮmIG#E^P,\JAQZh^dԡR-RZÄ(RkTpRu+"Jp^_3U&)GAfĖ-[$A|۶mYV&!?(.Lwp'Q"r&_˲^AoPr<  Rs:pll1O+T*}ݻvKyBpE:t(b1h}?o޼yfffff&P ꨯOQhcoZ%`KR8Y eYZX4DCaY9ۨ7fV2(1K1A҆R>I1F))6A`(*lv/L&)c K$( /͔Osƹ06 ϟ2ldP)-8m $7c33sX, m# $?3;WV"he{JN7/n:Dd1nD2QUsD3R$Mh۲ejZTR_-T<KӹlT**`[ViF6OTjYq^ ),FdDj3t>-1BJLĢZ8ҙLn>Όg G0F)"a/`㴰IdҰpYtuT`CKwJBFp %c%C\p4x<>99Imۨ“O>9<<\(|p88Ζ-[MmFD#:X Dm ,$r].Es1tݻi/m8޳gwsZvW\̌R*Le:\.?Ͼ袋+ KG~y9vͮ-Yj)-6 ҕbP,fs!H%LNM C!Ajul60|)C $iYd"0helYS v@RTj!"y=) ɤjm]8̬2p!,m4Qg˿w wޞi&JѯS41>18D4F@Z/+y" (D#h4j\ĘĨ4DAPz/7S&Agd~ES(bX$9S裏>J&W]u,_Sԩ وA!?q/YO?CBܰc@d2ihjECnB]_Ya1zqK_Hӹ|F +ddsŮAv+jz2Jg2NsX<'q0\XAՔ2lOO*=%RIYVJkT&0tX,$NfFFuI T|*ޘ͖2-H̘lCIL"p9!N9":s|>߿+W~W8m,3l\][t)Tb!( P(8qBB z,4X |&o~5kttt냃{.;x?`677Gg}SOBPE mmm`R)~(Ԣm\jr4[z6DQd𾘤0dY)ahEX|icŷ>Q,ՔHk"bEdk^/BŸu``+(?~SN  vǣjsss2bqopr""./dEwqY2t]fh) 꺾hѢ_~ȑ#TN;vX__ߊ+ Xr+P(ؘ灋89DQχ9xO}}}ݲ$1Si3N8Skd%EUTFZ4m@e#Hn1 CESP݂%#J7($HAY["Ld+&iTkZdȪDn%B,$ɚ^, H |m^oCDtZ*U$)"@ d={=z4L j1>fH0J`*XKŲaI) nwi I҅Z鲬鞋J,Vri3HtHl*ZQ pfYd(6tޗepKK ~gN#2Bp*Ոؤ+^ƈ1  4M$ ,+hJj整,KD(U^+(:[.Ɋ\ԁ[ec(_(d"YQT IRUWI$$!ɤCx%a5ݐ $YQ~WЀ1RUZ`+BrD'i 4Z؛sErEv51W*N4q7ę҇EyҥS6r>T*˵~8 z<3<8g[[4ur`PQ0`@D---..[ d2h~R)dJ!y󩪺k.":qYgG@,bxdɒ|;_~%2K$ .D"P(?88P(Gf+Gl9ijhRJ:AMDՌJeGF63t\ڨ:bz>WHSDZ֩ľ*Ɋ@ɲ!F9qlg%Lmk).OTEAD,$ɺA D(/8҆΀[ Ȳ*)Z,{.@Ya^1+'Lu]WU,ZEWˆ\V^CVbIU%B IVd]7 ݐ$C*/)$PTP(Jz)\Xvڍ3:EHnj^2eC+-$&T!`Pyvnde3w]m>yƊ"uttx^h@0|\;q9_Bp@Lwwwkk+ \Gz4ŷ\JTU) 2x@Dvnz:::_@+V|駋/A xg=zO?eYD"˖-[`ѣGܼpBNwUrW˨h9Y9Uy!9>JX%^1=SQICqB(tz't,^"!R2}TUhi:KRB_r@(MR(!i K4C|mD"4 rp$%o-ILe(NaP(ڲM $ {~x0eٰ$Sˤ`H?$Q6u>V:^r# ݒ%K2 ,P(5%K`)+VM&5Ꞟ? ,% ?'UVlPkkk0wpeEY|9. ~D"X`N9re:R$888HDpUsȑ!񩧞t.SNA=CMӒɤ8/`pNQɫhi" #Lf2Y K݊/E) FҘMtYV,+nͺ*]m䧒zd_2F 0bE[7fcR:eZZ2 4T.N]0Fpė.]X0 ^dW_} T(2 #B![hz0wPٝ \.| >*ʱKөTP(Cj~嗺777GQt.6 8xWD'x<'qiC,f,BnEۘ˰9BtAy d&vQM²Z]f!|4Ymzޑv "CG$aCiF"ƨ )1&26Fg3 Fb, |>Jej0;C L&<ς P|Wxhlnuwwcŋ\.0˗-[{ esr/pQ%-Z[[a/R[#ݓƢTFd]+$#v4]Sbm~+=0`XuY?"W"觟~?cYQ.eʕ:tiV^r>,n\paX-> {ｷj* À %KCS7[E$lhhSNኅa wxT €׿s.[ B/K^ L&@Lį}u9͖4yxum~tI K{ѓ,l SU"H$qy?dd7S96.ɠC4f=i\oCv{0Y[b>lXQ$Ɂ% bE"g/#G|Ǫ._U ,5 H$ B*D"=z]>`iR) x<\-|>'㚄TdD!7N``*@ ƹL&< )綵566SjԴҨ9G#TεRi.J\EV C$#b8WF12ǮG0žLHmpNT{IXxdɒ>lՍbxĉG| $;vaɒ%~,˱XP(S\Dv(PȔrrD dl6IP _u]ڻ̭2P'x<NxK .t`0z{{?auS|=]JFؽa*$(4>=oDc&ҁՋBi|#`.^Ed [eѣ~:!ippرc .|G- gyc+t]N?tEr`0Au@ F IDAT\6pV$)R)ؘH$`AO6L6G%M0i@X(va>"xŊ>/qT "[qF,BDtc>)3RˎHշ0ʍ 3+oozYGn.jWИޭKgd0l6jhhB˗/d20\ (2H \d-B^a|X?ёH$@ V H}CڜŐn7xD,>a u,-y.Cޮ ÑH^(?sDزx]$Ѫ5&"]l_8b1 D'`7D:>il63ppӦA\E Dq ĜZZZW^ys=ǿ?Q^鴮Uћoy96'wyK/ejHwa >q?qdҀb"D1=D4M~JI 10P-P>}W3Wp·j׾ܦ\溧S탡ެQkx\iWkQ%1HI^{k*9~E@JB!>s4> .>MeJf%I:tЙgIzo֥^JK8-*"&Ixp "5Uɧѭ?gqL~{5DK9m*G"hooO$}O׻pB"D"B!Aô `0d( iha(ʥ^ ; teβΆ,!"5=D/3?e]X^r`T袋'XD!W8`Ɛ#d $Րs:\|@_uŗ,n Vi'11'0yYSzXC`UMk)S dןgpdQR>@Ge HqY!v Ғ`u9ťA'H\,_}U*ekׂ(@(_kr]_u*'{<+Ot( /%m5"^B. pQ!r65WK~zN5;jh±s,ك\YΜ7AU ~\X4:].W4|gua$I^ niPω[%xÒɤfvT%KűG/g{;kƸ篾j$!rK/0 H\.׵^ H# / #XuUWޮr]K.+o~tL%t "yofepLfiok!DԢ$mx:0LӥJE$D A|U>lA:L?l6DɤI$,777cƜ6{ƀm N, $I%\J0uQ`0 8q;?vB Nuw#?RlTqUO)8G\N{MՊoֱiKŜƩJLx1yч6ƒ%9UdZټq[Mo?X"5Be-ZiMG,G,UщD`0LruttGD@c$~xWPs\:NӚKù\. Pg=H MMM$"EyWmTx<oVKKK4] PL,d\xC9Je2FDž} gQ8[ߌ㔫uqw,ٿ:^ 6𒮾>ʥ&:Nf~?J.[oB7x?B@oٲ: lP:VEaj|akY "x 4Jzk1 k09(u&R{뭷 (Ht"TJӴl6L&d>R$JOW*hRqjړpa5ˊ[OH:ֵ',>tYꨒod >/~O>i:]w裏򯝝| '(,P-Q%2vܮZ-UW]@d + -]_{kFIb`| qH/]q2EQW֮]k{z7"ŒL.>8AXQGiӶDkWF)Dq*8䘍A4Z(-_3/%/$@CsAfmXKaBgm:ԐEQ%HELySQ9a4?kv"5 >?p0,q&Dr@,(9No MÇ9rK/=ӣhkk3`"pJ4rp!`Z+bG`p\AV,G* =+񭊶{1WvIpZ]Ur9i )vAcyVsH$$Nw@xG̯; ǂL! ~-!P!o1QLE Xvo5їdXRZe49mt:],! =yiӇi8c( \vl9ɌR-Ȃ'K321m"Vg&*b)@D f1N/Urr5w4{}#?30 giO*ZpM,$ ζqƽ{[lgj %hI@B>gLL_~/"q\oL~B nя~DB^E.3 zu](ʳ>[nfOx<ɀ(- f%0 BZ 6Ij&HPE(Lߺ_)Ⱉt!.K4Tw- ̵ÒO'"(DlݺuDT(v޽yf>v:䴢9HU  /tMlw[8"WvmÖgy[n}gO\50 ּXvxs\>~p<37t*n Pf@)oŹJ&f~IvZ}c{U*nN$ "Z`Aؔkuu]߼yc=f]qA X$D]mfF*b-яGe;z??& QS_yu<[n,$ǁh|͢X8v!Ζ6l`C ?bN6m:p{9.Ws %NT 3zfК,kf&紨 N(.+͚2 Nq-b$m#QJr08\slśۀ:TgܿagJz(V.%79 x nA[g$B"D.dUSeZtz⫋ |?pز/䄘<,'LټPfb3bhMB9& 0z),8p;!_4%Iz'3an[$DpUxRb*yX}z~12MQ%Z \A% 'ɤR)߳gwQўQeL,$׳?~$,O=[Q,#~$ـF|w뮻 p$Ij{خP%}|6/>U'^Mhp;u{<jY?4+4qmڴiϞ=kgg'wV2b$Iw*xnFA[n:pyplg7O? vկ~-wy'r-Yx.8Rf~ *\l~w-I)(f,Xp9BYaK1(BUuNcזXsL*c&.q06T),BVב`w؄a8NsiN'S< D488zN;-+!B9Gl.Ʒ=&KH⳷SEUuїhƥru\ώ5gPw ( T*|d2rBP:6X'71U xTb%S`V2^4*^T怓pr=~L`@KK `*qHta!݇ Y„罘Tv2DpDXdr-mذA~t[oUtwqQ{뮻*lzvBy0vi֭[z,ENTj.vTki yqӯ8䦀O=p__ߢE嗸('?A֭gjsK  %eYfzjݺu_=pQLdzX@) $4^1k.fd\S%wڤL*؞DUrDi}}}XP(ˑ%1fÆ E9ޙfM9hE|z'ovq{nڴe{n1jΝAڵ Xe+s7DH\M*dV$ud&^>fr{Z>`b:X#SI96^(s(뷂#fa[OL Ŵ'QN#eqHDVY1E(ݼy3.$}Q"zGyTDdݱcǶmۘ"/&D&ޘ 1kpV3g 8RM6^7y*}7>CTET"d2KpeӦM!"L`ذIny DO^8v>p o:z+_%ti4!Bԏv=<#sϘÇzo۶m]th*BM*f?Y+j3ǧW\̇qW+*5nYny`%ÚP#k19+aMżc[s/Uq-ypͭ4)4|ӥJnrF'p4E%\Ƭ]jf΢p-SOzlb/M6q|G&BD)uw"DTkSidrt]]dӑWPRʃ( iXTj 1 [bIdRQ WĞ={ nޣ>*rȒ$IҎ;l5"ھ}x_]+|ӵU 5*-p~Ocw84~y46qjoo_p!Zn:[~=fd`鱚Mւ|'5駟fWO~,l YQGDխg_,䋌 "̒M9fMOdO+%sZi{ōӨ<]6{tfbTtIMT-Ss8K*¬WG $v-lF&ENd$M q1+Pnc?Y߱cFLjضmq$ ;t> s(uȄ=GiN;5ֆZ,J]|7 dRbzu[Ӵt:N䞊`i1/+v3Ή0i0k֛DX_ӲӦ} s}-;Xs$bm "dY. ,x7Q&#Jy^.& pCxbi L(aĔU > u'FG8QKYh)eTY1bJ+2*9Fw:iNl؆L $^l-Hk``aU1i+sӜfONe2v0gMRѸ&+UE{%BܒR&ݣiqT eUr[{k&+](f05HD #dL6,&UOdPv$y@ @Ml3lEuAPxbd&l8 >^>x}ծZ7Tɫ !j wGk{]=!ok`؈#8i|l.m6QsY1qPG,hkXkB&pgzꩧ֯_oSO=umY-$~]vmٲ7&2m۶M۷3>Od#Vol>֞1&qV/ q!S6Mׂsud:j|>1' t;e[ƍ>/ ڰaþ}ZRCv޽yfz;vf39۷ogZ93q1?ފ RsD|RaN=U3&2?N\*nTf*i> NŢf3S̪jޜHfq"ڳgG8Wl4D-5?ay6Ns6ZR4*b|L=5jEޟ}E&M!t-mcEu=bWlkZ-*`SS9]ƪ͛7ƍTj r,Z^5)*knIǜuMW|T ;}dé'cOִPQq; ˲=OCCCss3(PLr ryRU*Vo=&!Ma#m98! d0*gu}oBPSNqŌ`(>/Tɝu;UOco+;mը:IOhVCqg5m\FݎkCZjLO3DYh*'պ6gFi)>Fh0v֤%IJx>Ce IDATYۆ 2,KD\ٹ{nΝ;)o۶mY_⃏dWid8Y/6ix)uLLcVM~0G:'Րg]#B~rk+U{s:+? مvJ;vBHk- 0j"Xntb(;I裏}λv"N>?,>XjZyݤ\.jkZdJߧa3c{N6@* ~.΃tiEp(Gtr;d`Y%5[^X7) ZɴZR'CӸӦ˜ÝaIawȲ m5uIԎ-C&_tܛq l2;NsO3U-l=olrwXg~ָΌ2E ;49iLAKӪB~"h|>J&(hXiJbEDH,HUBp艿Vÿq5gȕ"d>Um&;*y}Cq{fxx_:u6qڌR%gx :|RǙ3&*b1$d*p;&.{5a=jLvUL?o (_+IOP|.$imdrT˶V4rv&"Q{תʈqFѣ>* Hr"SٹsNl4մs߫h6Vd&cl~W|q>$GbOV}GtԸT%I .\v[+ IQ4P(@B؇Ln-2nEAC>3{ټyfUrO$'+nJ+⠢r'"bu;ܦfO4G yƛnId7z Tb1 ƓUnܪ*dͬbg imVU&*fY+3qWGi_WOY;ia=~4Mbva'XW${LwORktfL#ć*;¯NsO*94Wrb'U*bLD5cf0F4U0NW#_8%349m|1Cl>, L852\sȖZyt r&XDäQMTQ%7:\ut8*T:l|T*e=!jEQBD#1SŚ) Dlܸq̾A$DtjQ%GF.*<`bQDU'7?f(G訒O nF(EWQ馛nzg>M<[W,L=E!>.Ό@IȤ(،D(@ey׮]`ݻ {݌wxÆaܹX,|P(0?#?@@X,vvvn߾=N@9+˵m۶]v1GQLZ, |9|P(81Q%qT'(IFppSIM&Qo$1qԔˍпb+u۷og @ Rt:f+ILⷑf3Lܒ$~pT͟e-(8PQ%eqJ*J^dYac1 фr+ j`omg﮻2ITX-m؂N'yqx8+P4C$Fg8Mg +"h6XɊӲϺ-da!"JR /~KD n?  .RzN%|luouHf/8Oc>{D ,5j鎉jcvZiQ_-Uhۓ2lj1S w֭.K\.rtM8eyR4,d<]P?i&"ڳgϦM{$I=]wU(qĢ ؽ{cMWTU׮]ѫzWK/]wu( 7"^|wXN~Xo*lOëWCQ%U;Q~c-*PrL ,0k Dfdb5&'ARUuϞ=v[0.+ \w07x~:wNUW^y6lxn7nsx+7ђ{rTɝ6vΰ='Iqfk֬Knw2\BEVYLU, Ȯ0>' S,[COKlVQ+I|^v{^rxTTt05!m=G|~x3l6OE {\.LZ I¦HxE1t($RQEFw4 EN@zCÏg0\`u!%{NsOUN M :SXFbk)5p2L4}Nx禤C`a.,EH$*;v ".Q/""kE*y*ڎ*yo~pD JZ㠫\b0<<|嗟wybZֳƜ}n](,T]w뺾Doj*}K"(cp`0D Aw؁Zvڶmηo>J^ʚU jpl:EJD "vʙjoEˀiT hR۷ou8p0?󃃃}}}o7bH$/^_yرe˖QkkkGGGGGG84-Hܹ3ڱcǖ-[p[n}衇oߎbN&ٽjXDyJ A٢Jn?KQ%ۃV .0 LT&! `a2}qcQ/vn*/DH$=`*+ ͎<)P%Q%WiwF51#Y!U= S6Q$QS56j,L[^o8F wDd"?44$/x׻\.׋'r\\.vCsxA5Jw 7xsА,h,n[_W|TO;4ŧe^ֳe_|UM$t`bGv@Abȓ"414(* Eywq{DtuqG}DDGYzuPX`AOOϊ+~C.9=W47+W4 N;rȊ+dYvg2p8ZT&ybdE:FԫV*&L(=k8'}z>fxx6]v}<TɫY*cjj6Z*%t0 dTftzxx1gSU iM>=(+wF8@D7x#TU]rdǣ(J8>3>S"袋* |a":3W .ꫯۡADH֕4~0Q^wppX,D+ TYP(XrcvMT5Y#a;boqZ:ni"lcާMxbCei%^MiT*J!fbᖆxҸ8:@ݡ^~c #Dr-|9SȲl2<Z\~@\Nuq,HL&Ap7r\#Lںex<߯z8x T;v,d2}>___g}x"~:v_4#Hd`9 8 I>d2W_}( 'd2iF( ^ \a6AQt[ X,pZ3Wu1  (l2IH=C=NKfl'A֭,pAʏ%ex,bHdhh(dh4NNsӜ6 &hx"b4(|\ANb8(/B\-5ȹ>!~Oo``X,/9b1Jv8P'd "3>TeٮT*a"q--- CUreQ%wTg f*9nݺ!"ZpKK$I---0/\.W03P(i^zeYpkʭ,}ѺuXߏSwY6ӛoID>L|5ki8n>TJ^" Ò$;+B z09 mhh~۝Q%jzUrrTg n[D~ /3BÀb 9uY+tOLgI߿;$_+Ѿq?k(K$毢(tzٲePsɒ>'%p"\ yLQ%Q%6UrʼnDȓrX /iO0PXE1c1<1sOԞ|ǸobeW^y_q.o\5k````` ˗}{/nhhXxq:f \pb DJAyRJpUG|&bnw D"/zfAAV5LiUuEy=5'<΢/#AΎ/ )^(DPH]>묳>l":S(.X /$"Zxl"H$ߦuTkZtyqTɭH樒[;6 νl6=88xǓɤ%N-@vɓ'9zoS/78D<[kʊG, ]%t:Jy?sD`*ZjS%70&%Kbd25M{wӃJ ;Xarʕ+:, bEm ,,VxZ *Rw#H{{{KK |wg(r,JDH8D28ʳkT(6ѷn?*Js>C^a&{/|t:}СǏ+H$իWXS|b B<?y#G{/!(hz^S!GM<=cZ$0MMMɲcDS4x>Inc]3, p2=lG~'Н?yI.]A@k>J$pp8N$XP(LI{w׮]cmڴMb IDATD/_}կ:(_{Tq644DQf2۷ў={M6o4mll㏿o+rժU^z\@D+Wd2DѣHu^UU 0~nwU[&J$O1ti=̝'TCk޴T&0:9}$\Rf*ccRpɒXKxNYf|o/9 Yd2 9! :(/W^}ķ?LDw}7YCP( !s۰a〝L&}>Ν;hx\UնX,G";vɆrCT(MujwyPIHv655]qHw=|,+Wϓ$||>sGDخ(ʪU.TE+ ʔD&j\j6 J`7Gp]d2}alG6]?L&**$˲Jߧa㴉0'ksdYaD?-_ rDݍ:F(hap^`~;gEYI@:R5E`dzF O$t g-YDQ\.r2L[[:tȑ#~ ^o<"mA&NNsӜDXx!eށx<)vq0F[ZZ B4Mx\Q`0ipp0H$ 0`SSqn1{Qʚ^&EQ 1χ BNvCØ,?M2FЉ|Lfxxv|> "` ̊9iNs$d|{x$r/B=K,1 #! p'u "jii>oʕ "O@lQGkgT*vkhh"m2|7OR4M?zP Xt)kP(fG4EQ4gTk ,9סY1=cuP}گ>g*y_OcvИ)+WZ'fdG?x<)c@ђ%Kz{{E#%<~3&a?֭[z!ƍ;y׮]5M{yUW]P tspDk?3+իW\@ `,BEC*9J^9M EiF:ȱ5m> W}VYqYMF` @v}Yg||g^LiZ4MӘa,Z(Nyx~*zƖ$G!Agkǎ[ntiwލ7rr.(P" >7tEyWT*L&xoo/ioiɓ'ʭHP~7 B劺d\J4U뾢Tcױ{,k_$̇<d~YC:Ӗ/_.I<àyt]F$C… E;:޽{;;;kq2xd]wm-T;,~&L ŏ>#Z@ɓ(Ke VeiŭP*BJSZ,oô"kk.Kg]Inɻ:Ζx{pi \ӯb]vOdrE-[ܹs˖-|OS$iϞ=6mE5ꫯDlꫯ^|ōz4E7޸+hڵ|/wqh( 1utR%=Cdg 22E&Xe68>6ĵ@ QaS6%(ڃDtUVFD_~%P˲x`0844J0 O  yKbv\{&Ј\7m~?.{뭷 8|ڵ/2$E|\s 0X,p8|uA_B.(xd@\Jj0YUj:ui37G,|ډkO\il|S}SۉDëV8544dzl:VQ oM۪-H:%ϙDHeJ&ʐ v'qB(m/>}ےٱ8cB  U -C[ 2ٲt4xugAǒlKhi}ֽ]:"U\pk' #BeۋfzEB[` nq`lG8(灟C `3бX ~Km+fU92 .is vktJsp-#aaH$|[]]]}ɓ'?O>䣏>裏>w}ĉgϞVxv 4XW zTUݾ};]H$pV@eee\rɸq{W]]+O~c`#vD!$ E`6\¸46 zُlύ$sX+99ݏUyH5i F2Ӷmjjj&N8vX!:::iGn<'H6`70_&Ik;L&VX{饗cZii)l>CDV_cж*`P$x"[*7L%ɘO)Í37,$}Mf!IFUUU?ٳpy^ 7 >7mF>h"cNرcƍV#1yf`WMM 8liiYj]޽{ׯ 6[ c.[ )ðUm?w{,ٷ1Oup8W^yh4 uT(pvhZ%i\k= D"`agVMxuD"=4xs!Y8.At(-8٪vAf7@oGŊT*%rYYS}&_9%%%¡Grv;ڈ(` -.ނ%st8/9-6[nvQH$[ii)dY< )mc](pBklo*xTt>'nvDQx˲8 YPHPx &/#2Ȩo!"&+hUY*IQ˫bT?<,G-^fGo6f/bmݺG!3J(A(#TUﯬz0eG;аa:;wnڴI81:= !A;lٲEe*E%c(倰M0p~QJnL#͵Gf Hkg^I`֭[lDe|\<~bn'7rmUQ%zH]B۰a!8N98B]A$֧lvK{ Qoϟ9sf;x1FD8ڈ"! %ϸ2mذ/0}x*$#%ݻw}߽{7Q7@e4 *yG'̞!q"EdeGΓknO>@Ձƣ[n I4&IA;\G>S':TjϞ=d3iyw|i]uͷ"Q%ת)gy,eiNn.]'KaYXتZE jޓe11vF0|_^ç+wp86oL1%IcTD Yq1644444޽{Td} pB=766YΪ @BhWħ4gN`xC0+.eP13~lPX!n2l,mM٪iYS%x<7ڙLVƍ8o9k׮=I #hݻwj*t֯PWWw^|^v-CU%O`1 +w].oB,aUyS1F#HII 4 tqt>B[~`rq| *DLMKGcw'M&f :Uu8BQ-oT7ľuC EQZ91 sN#+SGeKOɪ%32ȈL*yp%wvv?ʪ yr8贂qǓPA]L&us~X__;Z h*yLR$ѐg}ăJl|Uܰ2<\R{%0[|TɅ<2cs2vD"|j-cSUUHrBAsݺup!oHc#i&ɾ}jkk ;)zj0ؚ5khOZ BMf-OWYiB-a|Hk;J.V &ǃRXx،1hts$IƜp' ]#s}g¥əS0L4[nyO{,-Acٳ(xUVV)[~M7NFQp%bz8#5lMlM~lefW*9.Ur@;&}oـ 96]c[$?L&O ہL$ϻwnnn&W^MM;}x#dITjʕe 8$PW$HTɍ2& ^7h=F 3d0X]L4e12a2lUTɁF$ @gg'NFenn-+D]y/>޽gϞ+VR06msVZBe2ڳg^%A\Ƥ}Oium -Zyp&i$vGUɭʢJNT*QQQH$dYƞ.KX,(,˒$!|X+36l@e˖:tH$`Yɰnt8p`ƍ^w7nř媫3Ruf.ӥHJfV<ˍlʕx>Xi/6yh<W%' `*B+Z%Ba pE!D*Zdz匱p8Dn7G`yަaj-1#Y?#0/y ZȔo}݆)$ X$D"1qĊjxn)Spwww__bTE6BUïC/-aU]%{nv| -{^0ȁNǣjGG*kD\J$h4%@ 0f̘jt㖖VTT$p8aYYEl@d$Z!A^W BfEinv)DZHqܹ݀s~ʔ)ՑHx<2v}>%K1z:A0.N?@e<q Z0&Aܨ[V(q5U%s/tJ>oQZ?ꫯf\=Q?o>`PK.DQEQ{tʲxy:VMM s.v۶mY(N6]vWmV? |)AOU%ֺuZՖ *P,{N2+*xCAe+ɲ駟Θ1p] y^QRR ?t@8v8 {^ZZZ/_ŢѨz @ ;b|iAUrvh39{w}ʖn;K.eM<9c1ƦL2~xHBx<Y`\n*ad^'W.ڎ;tiI| A3ͣa䢢R%7v'%aeC1>3c4C (V%gåJnAl D"Ⱥ/_kkk[h0PB7IxdI2to|0 (2^9 hN HFfJ>R1~v:ܲj]ѭpI1_pn7 j!]x|>7lx<@RF6FtePv޽F/t+X t9$*9MaC,UG2-pldG_&+U gϞɹH@%Ib$_p T`\j$IMMMd'ڵkq|]]A(bcpڵ *0B8xgDJ]5 ^ZUr.W`k)sgSQA& )?F LпBӧOórBl ޗk rR؃ېG 7 Ғjkkq&*A|E+JAQ+j#gϞZѧ}=k"(,Ur#OQX:r6:p B|(Ƨ3zFJmUQ%6tL& QUUuwVUUR1c@Oe=c.=6_l2̀7HMRZqR唁KP֭h@&nHz\#t:mUr[&X*D"n^oOOOYYmH@x6I01@gGX,MubL0`t) |NJn%f60 @+!P)QҮ`/jHPF&ff7{a߄'|BzNܹs}+--*--p=HD"߯( Meh_Qb#~h`_ y21 0eÃ6s_'޹':f7-_,8ߏ_~رcKKK%I"Sv< S% F"H$(T md&D" ;fy%+DUQh^*yB m3}FEJNw x}ɓMMM'Nhood쳙3gL~( BBvıc}O~hIt+r?n6x㍰fbv~:) o.XMw߿|rAȃ*P-D Y((Ur+,*O&t[|dUɍ o&N!\j0tbׇөSc`]q_|̙3 jRgΜH$nƿ뮻td29mڴ/Aĉ_|q֬YeѣŋtgJC񨒏3ڀT3VV%O ,;UrFF$ &{ww7v;}? 29BQ3f}z$Aa@C(Cxyԩ Xu~W_}u4vrB³ZXEEtxGj0PxrZ* 9B8fQnŤJSJu[iIs*c?F!y{u8gΜ k PB___GGcWWWwuuM6mƌӧOͦQJn444y *]{ P(.ƍCd2Z]]]@VNEEEWWٳg?\mgΜǎCΝ3gl1c 1Ə1cF,D"믿>TVV47|S[[G ,ǃC#,D1-jxT*U$\3QhQJn%P|&OV%Ur- eݡz$BcǞ;wդIN~oB_|fd馛RUرc۹s窪ZZZsH$vF*:|9sTU$⋴ŋq… $Jb^cðUmKkRH$v믿^sϟO&cǎꪫƏW_!G_<zX3& !~6ǃH$S]]z8XT UUUȔ&X<~G}*WQVȞv*ǒ݊ÙAn.~tWQQp8~رcǏ+gOUU[ZZH$+))fP E XYYٔ)SMAȄ^Fb?f:_N.f c nv1> >4_VWWWWWWTTbK.K/En{{;ʷK Xp2X4;w,ˀȓN^/L+EQ~:ċi-uf7- 5,|>_8oǏ_]]]^^ .򲲲RUU8'bFʩc:௃|ubPt*/$EhF8]ñUu&Ga<|YB "S%7" ($(˲$I|7'OF5 Y?Agywy'c,RSp/F |!VfŬJnkR1zY-Zѫ[|F:;/Ǎ7bY{[nF@?0( DOSrǏg>0`tx:tR 0ҢU%D\)^4ݜmv`l*F@D"N%D 0z{{?ٳg%;vҪ^_򗌱W_}uΜ91L.}Qr=z,ZѣСC˖-K [F̕dDT MQ+ӑ},yA7,gm>QowϕAѨ77ɹӇvhoo?ydww?L&!SԩS(h1"p ")ĉn#@=gaٳểR23^xH1Ơ #S[ 8 OP!Ŝ1jUɍyZJ4X0(/ԾaQ!TK}fJn6^*+&>,AUU;::m۶~H$#n lozӟ2nPc|ٳ- :{͛71vRB^?փQUU Qt:}>R^`tw}w<2ѣ> cVrp`yZsZ{ٺemeϴѹZi/ڋ~A:|7]֩LφFGU5spߟ5kUUUSL+fΜgx/BP?OG}x$I/~1gΜ={6cldgɒ%O?4.ȑ#-gm&4D"W%TMͷn'opo*gvL?BDm͊466"$ 4?[ok8d?={v:>.]JSO-_1Pe2V\IZKj8 ƓJn7^p_QQD&AT"F^{ފ~L`vC.6tuu)'$ T5D@x^/<uk^cxG_вG arq NÆ@FOpi PYYܹsPx1dAIp(B^m8v8$|>%\|-h:HB[z/x9%~݆Um|{4Ctb/RUUe"9$IPHQ~ )q\ObG03 5" sp 0Z*2j$9y$Icƌ P e n<_ &f& (8̇Ȗz+rUrcDw܂Q̘`Mg k}ǣ@zAA܊$I'wM8q׿5r܂#uh#kf޽+Wj'O~z{nlYz5/RpyNEJnՊh"DDJ}?&>U}{u?~ѦJEQb`0 6 v7or\.{okk[pmmmg577]4WWW'-x;v]__OH8>cy6W/s*2UT|6SClҹL?cT-/ χP2<~y^/~~M758aiQ}&{뭷jPH`i/c1rJ+%E*Y̪VwF{ڈ5 aV629cځv8jRĈp|.󕕕AYt@rvrd>0>@{r-4 5%Izf͚u@BH IDAT8~9s1qo o. xIORZd4҆rg<'O} Td$ntomNbít:1~1cPIQ*HB!VQr Ҙn7Fo_x o&cwܡꭷ׿E2/@[o?~1os=NAT#@l( mƼKd3 UӺٳOb-1yC'4[z#!ࢮNIx-2'.dJA"6$"i({JK^0.+++))A)&<$-6"_"h㭷׹sR)&@;v؜9s/J q{7cwqב뮻[$a$z(ٳUV>@sWɦi6'e"Z(o5sޒ$R(dR$;}tē yF{zzzzz*++ă D@w<w:%%% g!(Д@$/rUd\;cejJI72iW,`%U*ѐ1'x<(x1ƮD"Wޠ9("=!v97oJ6{ɺ";^5qG2ƞ￟33W_e;v Sbl2%v7h"Gei /f,c+#M]{V|)L\]7H"DϬZ)~fE*lp40TYi;]K@F-]'N6mc,-TٟP.NqEˋ{gyE9pB1A T_yya^@& $[o*vq+d$" ԥ4ɯXUfaɃ*D4Ivt]u j JeBP,JM>ꫯ.//g={VUUY 3'y W}?s>|azϭ&/!9 ;~BHd#Ll?bcI}ŠJ֧0!ŪJ>(l56̸5l,%L4/7mL$\s͌3ƌCgYVVF8#61q FfDpEh"?  [O&/E"ÁSb1g͏& "bNx @1ߵ^{uuuE"X$$ɲ _<'oHQuZ*&k|PwG!X-v }D RZ1H$ħ$^z 4kꫯ"oz(ɼm"*"^ ֭Ǐwz(?]y^{-TJԵw};q B;$ےc21 Ë/9{guŇVU=zt:-z饗>}w0NH}7ow w-,u^F3*n VO+Urjԧ nLG8&ۺ>-[oPCQ4bCJN1RRR"'HɓO>-y]w! k:YF{ӟ>/^J7Ԗ.]p8:K,l~zɒ%|c-,mmm1p`?^x G^aobg Dh2CUmKkP>}TrA&fle-Y(TL d١30eWTTG"Y3Ƣ?H!x҈u/?~(I1$QA ;lx<i>h)~9́OOJ?n9/O&ɢq\|XQ@]q3fPMsZĽDɄ u { d `LW-bfG.@hՂx}&J೛lX׋i-'%nwwwwyy3*Xggg( }}}ضkF#'f%w%YfTw0A -.Avf7mX{(f ӧ_uU]]]TX0,'2iINa O( P!$_ qY*뇸|ҭxc0_?bP%NȌP0pk"j>c5.lǏ?1!)@|&c?w[VLs/--UU5 9.K/-//C>|Xmܹıf͙3GMp$/_ΏT*uKR'NjjjF >-[ WJ GD JtȑK/w߭U"|%x8E^᪒[zѝTk- [ X`j26euEy:|>yZmXMcx<%z{{Νt:S@E<W%`͛7*{Wi"@A$:V /^ZU HOU9O[ϺUm3K&,LHжUɵKX*qz].W8m۶iV6C+EԞnczR8Fo>8p`Ŋtt:*ҥK.\HE zꩇzhؐ x )UQ?#On  aFy1m4|,Ay +d뒡)za09k1i& `K.UEQ-HB$0i UVZVXᨫ#b5558n[[tRaSf1=zQ(}RWG lU#n6eC=PpWCwT@O@Q￟16被9D`׎"lwW.g2*S1Nq@rŠJ.ĊySY^{nݺ,l,uGpp' 8(84n86Pq|9 ť[hoBZF BT|1.mݺuӦM>/*xwkB3gM_~- )|{T tG\2dwlh1{-?i75)(ˇ&K/tܸqdt}w$ EQh"Y8{ &TVVȌBp׭l?; , k \|y{TSPI/l*VQ)W?{BbҤIn; ɲ4❐MD"q̙H$r6ݮͣХ:.SD ¯¥lpf7jCظqƎ rb$_5LM9ݢ2rbXL &d2Qied% BT @g[(HE! ^IףU%g(gL-%!>wޢ^ %`y ćS g)B,`L*G3C;yE ())|X_QsΡF0IV,'f*(jcc#clݺu&Exg\^.N ڙव-Z]̳`nr1 M.*+]Ln(#S6ZF?>*i&IE']eJv˓,eK/ţ|O pa-1N&$I,WVVBxL^~f׭{+&ݻIF:о}VXt:۷j*:C[[ҥKMf:b<駟YgD|*y94{⶙imA{AeR  8!PDEZ񵼼r^R{|x<@GFQ=JhnHxxU'`[1 [2=mr렒[4ÑzeLʵ )5>@f;`'LM1a6'o>noRIJ$PHQכ&zu8qz!ܥgyS'D3ABtT#.]dfքP`„oy<wUU)x$EEI9UAibPb0Y*tBiM`zJWF:OFAI&vP/ (I[TD!sұa¥i -aM&ljZ t7P@QQ]^^^UUUYY^/՘ zz2¢d=OFaz䵸x ,sPUV</("6ʩd3jm=Ӫnfk 7 '!K`p'-ZpE%+//;v,Aߏ8LL6/>}W\1qDPƅiW@aÆ]vaohhUXz={𹩩R[[LMxt _xf%Y=edZ?z]OW\1~xǓH$<OOOω'~ sPRFM/1tk[ܶrާFRl(ͯ$l EQ˻CP0t'NHTYY9iҤ*_ven?ccǎ+n7QnԩS'O ӤI*#fnIIRU1}c`|N69%ָD="kNeCU6bA9Ufm`Z`$Qe̙,G"H$H$(aa{UTT@>K$SN2eJuus:::$[2IT` iAeţf $9AlT @gen nv׋O.·:ˣhyy9**M,|>W_}t:`0XUU uKSOV8[^u=jvȗ=~©hd7n2M$OYEAq*냝늸|B&r]9ӀOЖ]K$*6|i"W%Ha@[V^\v{'YaMiK T]<'|WJ$=?itJ'8(eaDѹsvyN Å߆z,-:rrM{J֭n"un0p 6X'2ipy UU-[f;§7ºT(|3MXl=Ť9vؒ%Kc@Q"3Ν;FD5p(bkRI `iRiƍlnn^f WQ$PyIKd9LESa!S΅).nd>&gp umd9<-T*?H`bbNKH$I8///Dy*F MkllԖG{R)& Pcv!fѵUp9\ (U;>Y`ōLEPB!IY/H$B_g0$q^* $sΝ0aBII pt>!`c;x|jllDAȐ)C|؂0upmɥmHE=Z&72*'/mi.+n1+ #J>aL#Zoܼys,yM2wDxi˖-fz>.]F_N:q@ p^HΜ9<{|` Qi$aZqջw$<1 ݀|ѣG.\>4G+ӢE9}K. qd)dm8}]0Elm'm^=BiGP8~P8D UU~%\?y$yKD$dJ;L^PTU6me]>< X:e#^{ߍn%p8FrAAq"U|rݺ9 .4RU햃6i]^nY6N`vnݍ(MTQQQZZ״ |%ǡr@  t:P`i'\ ;8|q|= H3y]a nv׋dD1 KTVVh4 ; s=N'Xcɲ\UUK$1BP(ʉx!.GeWE^%H2Vch4