Update qtopia4 AVR32 patch to 4.3.1 (makes ARM work as well)

package/qtopia4/qtopia-4.3.1-add-avr32-arch.patch

@@ -0,0 +1,6139 @@
+diff -Nupr a/include/Qt/qatomic_avr32.h b/include/Qt/qatomic_avr32.h
+--- a/include/Qt/qatomic_avr32.h	1970-01-01 01:00:00.000000000 +0100
++++ b/include/Qt/qatomic_avr32.h	2006-07-27 07:55:09.000000000 +0200
+@@ -0,0 +1 @@
++#include "../../src/corelib/arch/qatomic_avr32.h"
+diff -Nupr a/include/QtCore/qatomic_avr32.h b/include/QtCore/qatomic_avr32.h
+--- a/include/QtCore/qatomic_avr32.h	1970-01-01 01:00:00.000000000 +0100
++++ b/include/QtCore/qatomic_avr32.h	2006-07-27 07:55:28.000000000 +0200
+@@ -0,0 +1 @@
++#include "../../src/corelib/arch/qatomic_avr32.h"
+diff -Nupr a/src/corelib/arch/arch.pri b/src/corelib/arch/arch.pri
+--- a/src/corelib/arch/arch.pri	2006-06-30 09:49:44.000000000 +0200
++++ b/src/corelib/arch/arch.pri	2006-07-26 11:03:43.000000000 +0200
+@@ -13,6 +13,7 @@ mac:HEADERS += arch/qatomic_macosx.h \
+                        arch/qatomic_generic.h \
+                        arch/qatomic_powerpc.h \
+                        arch/qatomic_arm.h \
++                       arch/qatomic_avr32.h \
+                        arch/qatomic_i386.h \
+                        arch/qatomic_mips.h \
+                        arch/qatomic_s390.h \
+diff -Nupr a/src/corelib/arch/avr32/arch.pri b/src/corelib/arch/avr32/arch.pri
+--- a/src/corelib/arch/avr32/arch.pri	1970-01-01 01:00:00.000000000 +0100
++++ b/src/corelib/arch/avr32/arch.pri	2006-07-26 11:02:16.000000000 +0200
+@@ -0,0 +1,5 @@
++#
++# AVR32 architecture
++#
++SOURCES += $$QT_ARCH_CPP/qatomic.cpp \
++           $$QT_ARCH_CPP/malloc.c
+diff -Nupr a/src/corelib/arch/avr32/malloc.c b/src/corelib/arch/avr32/malloc.c
+--- a/src/corelib/arch/avr32/malloc.c	1970-01-01 01:00:00.000000000 +0100
++++ b/src/corelib/arch/avr32/malloc.c	2006-07-28 10:29:44.000000000 +0200
+@@ -0,0 +1,5819 @@
++/****************************************************************************
++**
++** This file is part of the QtCore module of the Qt Toolkit.
++**
++** This file contains third party code which is not governed by the Qt
++** Commercial License Agreement. Please read the license headers below
++** for more information.
++**
++** Further information about Qt licensing is available at:
++** http://www.trolltech.com/products/qt/licensing.html or by
++** contacting info@trolltech.com.
++**
++** This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
++** WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
++**
++****************************************************************************/
++
++/* ---- config.h */
++#define KDE_MALLOC
++#define KDE_MALLOC_FULL
++#define KDE_MALLOC_AVR32
++/* ---- */
++
++#ifdef KDE_MALLOC
++
++#ifdef KDE_MALLOC_DEBUG
++#define DEBUG
++#endif
++
++#define USE_MALLOC_LOCK
++#define INLINE __inline__
++/*#define INLINE*/
++#define USE_MEMCPY 0
++#define MMAP_CLEARS 1
++
++/*
++  This is a version (aka dlmalloc) of malloc/free/realloc written by
++  Doug Lea and released to the public domain.  Use, modify, and
++  redistribute this code without permission or acknowledgment in any
++  way you wish.  Send questions, comments, complaints, performance
++  data, etc to dl@cs.oswego.edu
++
++* VERSION 2.7.0 Sun Mar 11 14:14:06 2001  Doug Lea  (dl at gee)
++
++   Note: There may be an updated version of this malloc obtainable at
++           ftp://gee.cs.oswego.edu/pub/misc/malloc.c
++         Check before installing!
++
++* Quickstart
++
++  This library is all in one file to simplify the most common usage:
++  ftp it, compile it (-O), and link it into another program. All
++  of the compile-time options default to reasonable values for use on
++  most unix platforms. Compile -DWIN32 for reasonable defaults on windows.
++  You might later want to step through various compile-time and dynamic
++  tuning options.
++
++  For convenience, an include file for code using this malloc is at:
++     ftp://gee.cs.oswego.edu/pub/misc/malloc-2.7.0.h
++  You don't really need this .h file unless you call functions not
++  defined in your system include files.  The .h file contains only the
++  excerpts from this file needed for using this malloc on ANSI C/C++
++  systems, so long as you haven't changed compile-time options about
++  naming and tuning parameters.  If you do, then you can create your
++  own malloc.h that does include all settings by cutting at the point
++  indicated below.
++
++* Why use this malloc?
++
++  This is not the fastest, most space-conserving, most portable, or
++  most tunable malloc ever written. However it is among the fastest
++  while also being among the most space-conserving, portable and tunable.
++  Consistent balance across these factors results in a good general-purpose
++  allocator for malloc-intensive programs.
++
++  The main properties of the algorithms are:
++  * For large (>= 512 bytes) requests, it is a pure best-fit allocator,
++    with ties normally decided via FIFO (i.e. least recently used).
++  * For small (<= 64 bytes by default) requests, it is a caching
++    allocator, that maintains pools of quickly recycled chunks.
++  * In between, and for combinations of large and small requests, it does
++    the best it can trying to meet both goals at once.
++  * For very large requests (>= 128KB by default), it relies on system
++    memory mapping facilities, if supported.
++
++  For a longer but slightly out of date high-level description, see
++     http://gee.cs.oswego.edu/dl/html/malloc.html
++
++  You may already by default be using a C library containing a malloc
++  that is  based on some version of this malloc (for example in
++  linux). You might still want to use the one in this file in order to
++  customize settings or to avoid overheads associated with library
++  versions.
++
++* Contents, described in more detail in "description of public routines" below.
++
++  Standard (ANSI/SVID/...)  functions:
++    malloc(size_t n);
++    calloc(size_t n_elements, size_t element_size);
++    free(Void_t* p);
++    realloc(Void_t* p, size_t n);
++    memalign(size_t alignment, size_t n);
++    valloc(size_t n);
++    mallinfo()
++    mallopt(int parameter_number, int parameter_value)
++
++  Additional functions:
++    independent_calloc(size_t n_elements, size_t size, Void_t* chunks[]);
++    independent_comalloc(size_t n_elements, size_t sizes[], Void_t* chunks[]);
++    pvalloc(size_t n);
++    cfree(Void_t* p);
++    malloc_trim(size_t pad);
++    malloc_usable_size(Void_t* p);
++    malloc_stats();
++
++* Vital statistics:
++
++  Supported pointer representation:       4 or 8 bytes
++  Supported size_t  representation:       4 or 8 bytes
++       Note that size_t is allowed to be 4 bytes even if pointers are 8.
++       You can adjust this by defining INTERNAL_SIZE_T
++
++  Alignment:                              2 * sizeof(size_t) (default)
++       (i.e., 8 byte alignment with 4byte size_t). This suffices for
++       nearly all current machines and C compilers. However, you can
++       define MALLOC_ALIGNMENT to be wider than this if necessary.
++
++  Minimum overhead per allocated chunk:   4 or 8 bytes
++       Each malloced chunk has a hidden word of overhead holding size
++       and status information.
++
++  Minimum allocated size: 4-byte ptrs:  16 bytes    (including 4 overhead)
++                          8-byte ptrs:  24/32 bytes (including, 4/8 overhead)
++
++       When a chunk is freed, 12 (for 4byte ptrs) or 20 (for 8 byte
++       ptrs but 4 byte size) or 24 (for 8/8) additional bytes are
++       needed; 4 (8) for a trailing size field and 8 (16) bytes for
++       free list pointers. Thus, the minimum allocatable size is
++       16/24/32 bytes.
++
++       Even a request for zero bytes (i.e., malloc(0)) returns a
++       pointer to something of the minimum allocatable size.
++
++       The maximum overhead wastage (i.e., number of extra bytes
++       allocated than were requested in malloc) is less than or equal
++       to the minimum size, except for requests >= mmap_threshold that
++       are serviced via mmap(), where the worst case wastage is 2 *
++       sizeof(size_t) bytes plus the remainder from a system page (the
++       minimal mmap unit); typically 4096 or 8192 bytes.
++
++  Maximum allocated size:  4-byte size_t: 2^32 minus about two pages
++                           8-byte size_t: 2^64 minus about two pages
++
++       It is assumed that (possibly signed) size_t values suffice to
++       represent chunk sizes. `Possibly signed' is due to the fact
++       that `size_t' may be defined on a system as either a signed or
++       an unsigned type. The ISO C standard says that it must be
++       unsigned, but a few systems are known not to adhere to this.
++       Additionally, even when size_t is unsigned, sbrk (which is by
++       default used to obtain memory from system) accepts signed
++       arguments, and may not be able to handle size_t-wide arguments
++       with negative sign bit.  Generally, values that would
++       appear as negative after accounting for overhead and alignment
++       are supported only via mmap(), which does not have this
++       limitation.
++
++       Requests for sizes outside the allowed range will perform an optional
++       failure action and then return null. (Requests may also
++       also fail because a system is out of memory.)
++
++  Thread-safety: NOT thread-safe unless USE_MALLOC_LOCK defined
++
++       When USE_MALLOC_LOCK is defined, wrappers are created to
++       surround every public call with either a pthread mutex or
++       a win32 spinlock (depending on WIN32). This is not
++       especially fast, and can be a major bottleneck.
++       It is designed only to provide minimal protection
++       in concurrent environments, and to provide a basis for
++       extensions.  If you are using malloc in a concurrent program,
++       you would be far better off obtaining ptmalloc, which is
++       derived from a version of this malloc, and is well-tuned for
++       concurrent programs. (See http://www.malloc.de)
++
++  Compliance: I believe it is compliant with the 1997 Single Unix Specification
++       (See http://www.opennc.org). Also SVID/XPG, ANSI C, and probably
++       others as well.
++
++* Synopsis of compile-time options:
++
++    People have reported using previous versions of this malloc on all
++    versions of Unix, sometimes by tweaking some of the defines
++    below. It has been tested most extensively on Solaris and
++    Linux. It is also reported to work on WIN32 platforms.
++    People also report using it in stand-alone embedded systems.
++
++    The implementation is in straight, hand-tuned ANSI C.  It is not
++    at all modular. (Sorry!)  It uses a lot of macros.  To be at all
++    usable, this code should be compiled using an optimizing compiler
++    (for example gcc -O3) that can simplify expressions and control
++    paths. (FAQ: some macros import variables as arguments rather than
++    declare locals because people reported that some debuggers
++    otherwise get confused.)
++
++    OPTION                     DEFAULT VALUE
++
++    Compilation Environment options:
++
++    __STD_C                    derived from C compiler defines
++    WIN32                      NOT defined
++    HAVE_MEMCPY                defined
++    USE_MEMCPY                 1 if HAVE_MEMCPY is defined
++    HAVE_MMAP                  defined as 1
++    MMAP_CLEARS                1
++    HAVE_MREMAP                0 unless linux defined
++    malloc_getpagesize         derived from system #includes, or 4096 if not
++    HAVE_USR_INCLUDE_MALLOC_H  NOT defined
++    LACKS_UNISTD_H             NOT defined unless WIN32
++    LACKS_SYS_PARAM_H          NOT defined unless WIN32
++    LACKS_SYS_MMAN_H           NOT defined unless WIN32
++
++    Changing default word sizes:
++
++    INTERNAL_SIZE_T            size_t
++    MALLOC_ALIGNMENT           2 * sizeof(INTERNAL_SIZE_T)
++
++    Configuration and functionality options:
++
++    USE_DL_PREFIX              NOT defined
++    USE_PUBLIC_MALLOC_WRAPPERS NOT defined
++    USE_MALLOC_LOCK            NOT defined
++    DEBUG                      NOT defined
++    REALLOC_ZERO_BYTES_FREES   NOT defined
++    MALLOC_FAILURE_ACTION      errno = ENOMEM, if __STD_C defined, else no-op
++    TRIM_FASTBINS              0
++
++    Options for customizing MORECORE:
++
++    MORECORE                   sbrk
++    MORECORE_CONTIGUOUS        1
++    MORECORE_CANNOT_TRIM       NOT defined
++    MMAP_AS_MORECORE_SIZE      (1024 * 1024)
++
++    Tuning options that are also dynamically changeable via mallopt:
++
++    DEFAULT_MXFAST             64
++    DEFAULT_TRIM_THRESHOLD     128 * 1024
++    DEFAULT_TOP_PAD            0
++    DEFAULT_MMAP_THRESHOLD     128 * 1024
++    DEFAULT_MMAP_MAX           65536
++
++    There are several other #defined constants and macros that you
++    probably don't want to touch unless you are extending or adapting malloc.
++*/
++
++/*
++  WIN32 sets up defaults for MS environment and compilers.
++  Otherwise defaults are for unix.
++*/
++
++/* #define WIN32 */
++
++#ifdef WIN32
++
++#define WIN32_LEAN_AND_MEAN
++#include <windows.h>
++
++/* Win32 doesn't supply or need the following headers */
++#define LACKS_UNISTD_H
++#define LACKS_SYS_PARAM_H
++#define LACKS_SYS_MMAN_H
++
++/* Use the supplied emulation of sbrk */
++#define MORECORE sbrk
++#define MORECORE_CONTIGUOUS 1
++#define MORECORE_FAILURE    ((void*)(-1))
++
++/* Use the supplied emulation of mmap and munmap */
++#define HAVE_MMAP 1
++#define MUNMAP_FAILURE  (-1)
++#define MMAP_CLEARS 1
++
++/* These values don't really matter in windows mmap emulation */
++#define MAP_PRIVATE 1
++#define MAP_ANONYMOUS 2
++#define PROT_READ 1
++#define PROT_WRITE 2
++
++/* Emulation functions defined at the end of this file */
++
++/* If USE_MALLOC_LOCK, use supplied critical-section-based lock functions */
++#ifdef USE_MALLOC_LOCK
++static int slwait(int *sl);
++static int slrelease(int *sl);
++#endif
++
++static long getpagesize(void);
++static long getregionsize(void);
++static void *sbrk(long size);
++static void *mmap(void *ptr, long size, long prot, long type, long handle, long arg);
++static long munmap(void *ptr, long size);
++
++static void vminfo (unsigned long *free, unsigned long *reserved, unsigned long *committed);
++static int cpuinfo (int whole, unsigned long *kernel, unsigned long *user);
++
++#endif
++
++/*
++  __STD_C should be nonzero if using ANSI-standard C compiler, a C++
++  compiler, or a C compiler sufficiently close to ANSI to get away
++  with it.
++*/
++
++#ifndef __STD_C
++#if defined(__STDC__) || defined(_cplusplus)
++#define __STD_C     1
++#else
++#define __STD_C     0
++#endif
++#endif /*__STD_C*/
++
++
++/*
++  Void_t* is the pointer type that malloc should say it returns
++*/
++
++#ifndef Void_t
++#if (__STD_C || defined(WIN32))
++#define Void_t      void
++#else
++#define Void_t      char
++#endif
++#endif /*Void_t*/
++
++#if __STD_C
++#include <stddef.h>   /* for size_t */
++#else
++#include <sys/types.h>
++#endif
++
++#ifdef __cplusplus
++extern "C" {
++#endif
++
++/* define LACKS_UNISTD_H if your system does not have a <unistd.h>. */
++
++/* #define  LACKS_UNISTD_H */
++
++#ifndef LACKS_UNISTD_H
++#include <unistd.h>
++#endif
++
++/* define LACKS_SYS_PARAM_H if your system does not have a <sys/param.h>. */
++
++/* #define  LACKS_SYS_PARAM_H */
++
++
++#include <stdio.h>    /* needed for malloc_stats */
++#include <errno.h>    /* needed for optional MALLOC_FAILURE_ACTION */
++
++
++/*
++  Debugging:
++
++  Because freed chunks may be overwritten with bookkeeping fields, this
++  malloc will often die when freed memory is overwritten by user
++  programs.  This can be very effective (albeit in an annoying way)
++  in helping track down dangling pointers.
++
++  If you compile with -DDEBUG, a number of assertion checks are
++  enabled that will catch more memory errors. You probably won't be
++  able to make much sense of the actual assertion errors, but they
++  should help you locate incorrectly overwritten memory.  The
++  checking is fairly extensive, and will slow down execution
++  noticeably. Calling malloc_stats or mallinfo with DEBUG set will
++  attempt to check every non-mmapped allocated and free chunk in the
++  course of computing the summmaries. (By nature, mmapped regions
++  cannot be checked very much automatically.)
++
++  Setting DEBUG may also be helpful if you are trying to modify
++  this code. The assertions in the check routines spell out in more
++  detail the assumptions and invariants underlying the algorithms.
++
++  Setting DEBUG does NOT provide an automated mechanism for checking
++  that all accesses to malloced memory stay within their
++  bounds. However, there are several add-ons and adaptations of this
++  or other mallocs available that do this.
++*/
++
++#ifdef DEBUG
++#include <assert.h>
++#else
++#define assert(x) ((void)0)
++#endif
++
++
++/*
++  INTERNAL_SIZE_T is the word-size used for internal bookkeeping
++  of chunk sizes.
++
++  The default version is the same as size_t.
++
++  While not strictly necessary, it is best to define this as an
++  unsigned type, even if size_t is a signed type. This may avoid some
++  artificial size limitations on some systems.
++
++  On a 64-bit machine, you may be able to reduce malloc overhead by
++  defining INTERNAL_SIZE_T to be a 32 bit `unsigned int' at the
++  expense of not being able to handle more than 2^32 of malloced
++  space. If this limitation is acceptable, you are encouraged to set
++  this unless you are on a platform requiring 16byte alignments. In
++  this case the alignment requirements turn out to negate any
++  potential advantages of decreasing size_t word size.
++
++  Implementors: Beware of the possible combinations of:
++     - INTERNAL_SIZE_T might be signed or unsigned, might be 32 or 64 bits,
++       and might be the same width as int or as long
++     - size_t might have different width and signedness as INTERNAL_SIZE_T
++     - int and long might be 32 or 64 bits, and might be the same width
++  To deal with this, most comparisons and difference computations
++  among INTERNAL_SIZE_Ts should cast them to unsigned long, being
++  aware of the fact that casting an unsigned int to a wider long does
++  not sign-extend. (This also makes checking for negative numbers
++  awkward.) Some of these casts result in harmless compiler warnings
++  on some systems.
++*/
++
++#ifndef INTERNAL_SIZE_T
++#define INTERNAL_SIZE_T size_t
++#endif
++
++/* The corresponding word size */
++#define SIZE_SZ                (sizeof(INTERNAL_SIZE_T))
++
++
++/*
++  MALLOC_ALIGNMENT is the minimum alignment for malloc'ed chunks.
++  It must be a power of two at least 2 * SIZE_SZ, even on machines
++  for which smaller alignments would suffice. It may be defined as
++  larger than this though. Note however that code and data structures
++  are optimized for the case of 8-byte alignment.
++*/
++
++
++#ifndef MALLOC_ALIGNMENT
++#define MALLOC_ALIGNMENT       (2 * SIZE_SZ)
++#endif
++
++/* The corresponding bit mask value */
++#define MALLOC_ALIGN_MASK      (MALLOC_ALIGNMENT - 1)
++
++
++
++/*
++  REALLOC_ZERO_BYTES_FREES should be set if a call to
++  realloc with zero bytes should be the same as a call to free.
++  Some people think it should. Otherwise, since this malloc
++  returns a unique pointer for malloc(0), so does realloc(p, 0).
++*/
++
++/*   #define REALLOC_ZERO_BYTES_FREES */
++
++/*
++  TRIM_FASTBINS controls whether free() of a very small chunk can
++  immediately lead to trimming. Setting to true (1) can reduce memory
++  footprint, but will almost always slow down programs that use a lot
++  of small chunks.
++
++  Define this only if you are willing to give up some speed to more
++  aggressively reduce system-level memory footprint when releasing
++  memory in programs that use many small chunks.  You can get
++  essentially the same effect by setting MXFAST to 0, but this can
++  lead to even greater slowdowns in programs using many small chunks.
++  TRIM_FASTBINS is an in-between compile-time option, that disables
++  only those chunks bordering topmost memory from being placed in
++  fastbins.
++*/
++
++#ifndef TRIM_FASTBINS
++#define TRIM_FASTBINS  0
++#endif
++
++
++/*
++  USE_DL_PREFIX will prefix all public routines with the string 'dl'.
++  This is necessary when you only want to use this malloc in one part
++  of a program, using your regular system malloc elsewhere.
++*/
++
++/* #define USE_DL_PREFIX */
++
++
++/*
++  USE_MALLOC_LOCK causes wrapper functions to surround each
++  callable routine with pthread mutex lock/unlock.
++
++  USE_MALLOC_LOCK forces USE_PUBLIC_MALLOC_WRAPPERS to be defined
++*/
++
++
++/* #define USE_MALLOC_LOCK */
++
++
++/*
++  If USE_PUBLIC_MALLOC_WRAPPERS is defined, every public routine is
++  actually a wrapper function that first calls MALLOC_PREACTION, then
++  calls the internal routine, and follows it with
++  MALLOC_POSTACTION. This is needed for locking, but you can also use
++  this, without USE_MALLOC_LOCK, for purposes of interception,
++  instrumentation, etc. It is a sad fact that using wrappers often
++  noticeably degrades performance of malloc-intensive programs.
++*/
++
++#ifdef USE_MALLOC_LOCK
++#define USE_PUBLIC_MALLOC_WRAPPERS
++#else
++/* #define USE_PUBLIC_MALLOC_WRAPPERS */
++#endif
++
++
++/*
++   Two-phase name translation.
++   All of the actual routines are given mangled names.
++   When wrappers are used, they become the public callable versions.
++   When DL_PREFIX is used, the callable names are prefixed.
++*/
++
++#ifndef USE_PUBLIC_MALLOC_WRAPPERS
++#define cALLOc      public_cALLOc
++#define fREe        public_fREe
++#define cFREe       public_cFREe
++#define mALLOc      public_mALLOc
++#define mEMALIGn    public_mEMALIGn
++#define rEALLOc     public_rEALLOc
++#define vALLOc      public_vALLOc
++#define pVALLOc     public_pVALLOc
++#define mALLINFo    public_mALLINFo
++#define mALLOPt     public_mALLOPt
++#define mTRIm       public_mTRIm
++#define mSTATs      public_mSTATs
++#define mUSABLe     public_mUSABLe
++#define iCALLOc     public_iCALLOc
++#define iCOMALLOc   public_iCOMALLOc
++#endif
++
++#ifdef USE_DL_PREFIX
++#define public_cALLOc    dlcalloc
++#define public_fREe      dlfree
++#define public_cFREe     dlcfree
++#define public_mALLOc    dlmalloc
++#define public_mEMALIGn  dlmemalign
++#define public_rEALLOc   dlrealloc
++#define public_vALLOc    dlvalloc
++#define public_pVALLOc   dlpvalloc
++#define public_mALLINFo  dlmallinfo
++#define public_mALLOPt   dlmallopt
++#define public_mTRIm     dlmalloc_trim
++#define public_mSTATs    dlmalloc_stats
++#define public_mUSABLe   dlmalloc_usable_size
++#define public_iCALLOc   dlindependent_calloc
++#define public_iCOMALLOc dlindependent_comalloc
++#else /* USE_DL_PREFIX */
++#define public_cALLOc    calloc
++#define public_fREe      free
++#define public_cFREe     cfree
++#define public_mALLOc    malloc
++#define public_mEMALIGn  memalign
++#define public_rEALLOc   realloc
++#define public_vALLOc    valloc
++#define public_pVALLOc   pvalloc
++#define public_mALLINFo  mallinfo
++#define public_mALLOPt   mallopt
++#define public_mTRIm     malloc_trim
++#define public_mSTATs    malloc_stats
++#define public_mUSABLe   malloc_usable_size
++#define public_iCALLOc   independent_calloc
++#define public_iCOMALLOc independent_comalloc
++#endif /* USE_DL_PREFIX */
++
++
++/*
++  HAVE_MEMCPY should be defined if you are not otherwise using
++  ANSI STD C, but still have memcpy and memset in your C library
++  and want to use them in calloc and realloc. Otherwise simple
++  macro versions are defined below.
++
++  USE_MEMCPY should be defined as 1 if you actually want to
++  have memset and memcpy called. People report that the macro
++  versions are faster than libc versions on some systems.
++
++  Even if USE_MEMCPY is set to 1, loops to copy/clear small chunks
++  (of <= 36 bytes) are manually unrolled in realloc and calloc.
++*/
++
++/* If it's available it's defined in config.h.  */
++/* #define HAVE_MEMCPY */
++
++#ifndef USE_MEMCPY
++#ifdef HAVE_MEMCPY
++#define USE_MEMCPY 1
++#else
++#define USE_MEMCPY 0
++#endif
++#endif
++
++
++#if (__STD_C || defined(HAVE_MEMCPY))
++
++#ifdef WIN32
++/* On Win32 memset and memcpy are already declared in windows.h */
++#else
++#if __STD_C
++void* memset(void*, int, size_t);
++void* memcpy(void*, const void*, size_t);
++#else
++Void_t* memset();
++Void_t* memcpy();
++#endif
++#endif
++#endif
++
++/*
++  MALLOC_FAILURE_ACTION is the action to take before "return 0" when
++  malloc fails to be able to return memory, either because memory is
++  exhausted or because of illegal arguments.
++
++  By default, sets errno if running on STD_C platform, else does nothing.
++*/
++
++#ifndef MALLOC_FAILURE_ACTION
++#if __STD_C
++#define MALLOC_FAILURE_ACTION \
++   errno = ENOMEM;
++
++#else
++#define MALLOC_FAILURE_ACTION
++#endif
++#endif
++
++/*
++  MORECORE-related declarations. By default, rely on sbrk
++*/
++
++
++#ifdef LACKS_UNISTD_H
++#if !defined(__FreeBSD__) && !defined(__OpenBSD__) && !defined(__NetBSD__)
++#if __STD_C
++extern Void_t*     sbrk(ptrdiff_t);
++#else
++extern Void_t*     sbrk();
++#endif
++#endif
++#endif
++
++/*
++  MORECORE is the name of the routine to call to obtain more memory
++  from the system.  See below for general guidance on writing
++  alternative MORECORE functions, as well as a version for WIN32 and a
++  sample version for pre-OSX macos.
++*/
++
++#ifndef MORECORE
++#define MORECORE sbrk
++#endif
++
++/*
++  MORECORE_FAILURE is the value returned upon failure of MORECORE
++  as well as mmap. Since it cannot be an otherwise valid memory address,
++  and must reflect values of standard sys calls, you probably ought not
++  try to redefine it.
++*/
++
++#ifndef MORECORE_FAILURE
++#define MORECORE_FAILURE (-1)
++#endif
++
++/*
++  If MORECORE_CONTIGUOUS is true, take advantage of fact that
++  consecutive calls to MORECORE with positive arguments always return
++  contiguous increasing addresses.  This is true of unix sbrk.  Even
++  if not defined, when regions happen to be contiguous, malloc will
++  permit allocations spanning regions obtained from different
++  calls. But defining this when applicable enables some stronger
++  consistency checks and space efficiencies.
++*/
++
++#ifndef MORECORE_CONTIGUOUS
++#define MORECORE_CONTIGUOUS 1
++#endif
++
++/*
++  Define MORECORE_CANNOT_TRIM if your version of MORECORE
++  cannot release space back to the system when given negative
++  arguments. This is generally necessary only if you are using
++  a hand-crafted MORECORE function that cannot handle negative arguments.
++*/
++
++/* #define MORECORE_CANNOT_TRIM */
++
++
++/*
++  Define HAVE_MMAP as true to optionally make malloc() use mmap() to
++  allocate very large blocks.  These will be returned to the
++  operating system immediately after a free(). Also, if mmap
++  is available, it is used as a backup strategy in cases where
++  MORECORE fails to provide space from system.
++
++  This malloc is best tuned to work with mmap for large requests.
++  If you do not have mmap, operations involving very large chunks (1MB
++  or so) may be slower than you'd like.
++*/
++
++#ifndef HAVE_MMAP
++#define HAVE_MMAP 1
++#endif
++
++#if HAVE_MMAP
++/*
++   Standard unix mmap using /dev/zero clears memory so calloc doesn't
++   need to.
++*/
++
++#ifndef MMAP_CLEARS
++#define MMAP_CLEARS 1
++#endif
++
++#else /* no mmap */
++#ifndef MMAP_CLEARS
++#define MMAP_CLEARS 0
++#endif
++#endif
++
++
++/*
++   MMAP_AS_MORECORE_SIZE is the minimum mmap size argument to use if
++   sbrk fails, and mmap is used as a backup (which is done only if
++   HAVE_MMAP).  The value must be a multiple of page size.  This
++   backup strategy generally applies only when systems have "holes" in
++   address space, so sbrk cannot perform contiguous expansion, but
++   there is still space available on system.  On systems for which
++   this is known to be useful (i.e. most linux kernels), this occurs
++   only when programs allocate huge amounts of memory.  Between this,
++   and the fact that mmap regions tend to be limited, the size should
++   be large, to avoid too many mmap calls and thus avoid running out
++   of kernel resources.
++*/
++
++#ifndef MMAP_AS_MORECORE_SIZE
++#define MMAP_AS_MORECORE_SIZE (1024 * 1024)
++#endif
++
++/*
++  Define HAVE_MREMAP to make realloc() use mremap() to re-allocate
++  large blocks.  This is currently only possible on Linux with
++  kernel versions newer than 1.3.77.
++*/
++
++#ifndef HAVE_MREMAP
++#if defined(linux) || defined(__linux__) || defined(__linux)
++#define HAVE_MREMAP 1
++#else
++#define HAVE_MREMAP 0
++#endif
++
++#endif /* HAVE_MMAP */
++
++
++/*
++  The system page size. To the extent possible, this malloc manages
++  memory from the system in page-size units.  Note that this value is
++  cached during initialization into a field of malloc_state. So even
++  if malloc_getpagesize is a function, it is only called once.
++
++  The following mechanics for getpagesize were adapted from bsd/gnu
++  getpagesize.h. If none of the system-probes here apply, a value of
++  4096 is used, which should be OK: If they don't apply, then using
++  the actual value probably doesn't impact performance.
++*/
++
++
++#ifndef malloc_getpagesize
++
++#ifndef LACKS_UNISTD_H
++#  include <unistd.h>
++#endif
++
++#  ifdef _SC_PAGESIZE         /* some SVR4 systems omit an underscore */
++#    ifndef _SC_PAGE_SIZE
++#      define _SC_PAGE_SIZE _SC_PAGESIZE
++#    endif
++#  endif
++
++#  ifdef _SC_PAGE_SIZE
++#    define malloc_getpagesize sysconf(_SC_PAGE_SIZE)
++#  else
++#    if defined(BSD) || defined(DGUX) || defined(HAVE_GETPAGESIZE)
++       extern size_t getpagesize();
++#      define malloc_getpagesize getpagesize()
++#    else
++#      ifdef WIN32 /* use supplied emulation of getpagesize */
++#        define malloc_getpagesize getpagesize()
++#      else
++#        ifndef LACKS_SYS_PARAM_H
++#          include <sys/param.h>
++#        endif
++#        ifdef EXEC_PAGESIZE
++#          define malloc_getpagesize EXEC_PAGESIZE
++#        else
++#          ifdef NBPG
++#            ifndef CLSIZE
++#              define malloc_getpagesize NBPG
++#            else
++#              define malloc_getpagesize (NBPG * CLSIZE)
++#            endif
++#          else
++#            ifdef NBPC
++#              define malloc_getpagesize NBPC
++#            else
++#              ifdef PAGESIZE
++#                define malloc_getpagesize PAGESIZE
++#              else /* just guess */
++#                define malloc_getpagesize (4096)
++#              endif
++#            endif
++#          endif
++#        endif
++#      endif
++#    endif
++#  endif
++#endif
++
++/*
++  This version of malloc supports the standard SVID/XPG mallinfo
++  routine that returns a struct containing usage properties and
++  statistics. It should work on any SVID/XPG compliant system that has
++  a /usr/include/malloc.h defining struct mallinfo. (If you'd like to
++  install such a thing yourself, cut out the preliminary declarations
++  as described above and below and save them in a malloc.h file. But
++  there's no compelling reason to bother to do this.)
++
++  The main declaration needed is the mallinfo struct that is returned
++  (by-copy) by mallinfo().  The SVID/XPG malloinfo struct contains a
++  bunch of field that are not even meaningful in this version of
++  malloc.  These fields are are instead filled by mallinfo() with
++  other numbers that might be of interest.
++
++  HAVE_USR_INCLUDE_MALLOC_H should be set if you have a
++  /usr/include/malloc.h file that includes a declaration of struct
++  mallinfo.  If so, it is included; else an SVID2/XPG2 compliant
++  version is declared below.  These must be precisely the same for
++  mallinfo() to work.  The original SVID version of this struct,
++  defined on most systems with mallinfo, declares all fields as
++  ints. But some others define as unsigned long. If your system
++  defines the fields using a type of different width than listed here,
++  you must #include your system version and #define
++  HAVE_USR_INCLUDE_MALLOC_H.
++*/
++
++/* #define HAVE_USR_INCLUDE_MALLOC_H */
++
++/*#ifdef HAVE_USR_INCLUDE_MALLOC_H*/
++#if 0
++#include "/usr/include/malloc.h"
++#else
++
++/* SVID2/XPG mallinfo structure */
++
++struct mallinfo {
++  int arena;    /* non-mmapped space allocated from system */
++  int ordblks;  /* number of free chunks */
++  int smblks;   /* number of fastbin blocks */
++  int hblks;    /* number of mmapped regions */
++  int hblkhd;   /* space in mmapped regions */
++  int usmblks;  /* maximum total allocated space */
++  int fsmblks;  /* space available in freed fastbin blocks */
++  int uordblks; /* total allocated space */
++  int fordblks; /* total free space */
++  int keepcost; /* top-most, releasable (via malloc_trim) space */
++};
++
++/*
++  SVID/XPG defines four standard parameter numbers for mallopt,
++  normally defined in malloc.h.  Only one of these (M_MXFAST) is used
++  in this malloc. The others (M_NLBLKS, M_GRAIN, M_KEEP) don't apply,
++  so setting them has no effect. But this malloc also supports other
++  options in mallopt described below.
++*/
++#endif
++
++
++/* ---------- description of public routines ------------ */
++
++/*
++  malloc(size_t n)
++  Returns a pointer to a newly allocated chunk of at least n bytes, or null
++  if no space is available. Additionally, on failure, errno is
++  set to ENOMEM on ANSI C systems.
++
++  If n is zero, malloc returns a minumum-sized chunk. (The minimum
++  size is 16 bytes on most 32bit systems, and 24 or 32 bytes on 64bit
++  systems.)  On most systems, size_t is an unsigned type, so calls
++  with negative arguments are interpreted as requests for huge amounts
++  of space, which will often fail. The maximum supported value of n
++  differs across systems, but is in all cases less than the maximum
++  representable value of a size_t.
++*/
++#if __STD_C
++Void_t*  public_mALLOc(size_t);
++#else
++Void_t*  public_mALLOc();
++#endif
++
++/*
++  free(Void_t* p)
++  Releases the chunk of memory pointed to by p, that had been previously
++  allocated using malloc or a related routine such as realloc.
++  It has no effect if p is null. It can have arbitrary (i.e., bad!)
++  effects if p has already been freed.
++
++  Unless disabled (using mallopt), freeing very large spaces will
++  when possible, automatically trigger operations that give
++  back unused memory to the system, thus reducing program footprint.
++*/
++#if __STD_C
++void     public_fREe(Void_t*);
++#else
++void     public_fREe();
++#endif
++
++/*
++  calloc(size_t n_elements, size_t element_size);
++  Returns a pointer to n_elements * element_size bytes, with all locations
++  set to zero.
++*/
++#if __STD_C
++Void_t*  public_cALLOc(size_t, size_t);
++#else
++Void_t*  public_cALLOc();
++#endif
++
++/*
++  realloc(Void_t* p, size_t n)
++  Returns a pointer to a chunk of size n that contains the same data
++  as does chunk p up to the minimum of (n, p's size) bytes, or null
++  if no space is available.
++
++  The returned pointer may or may not be the same as p. The algorithm
++  prefers extending p when possible, otherwise it employs the
++  equivalent of a malloc-copy-free sequence.
++
++  If p is null, realloc is equivalent to malloc.
++
++  If space is not available, realloc returns null, errno is set (if on
++  ANSI) and p is NOT freed.
++
++  if n is for fewer bytes than already held by p, the newly unused
++  space is lopped off and freed if possible.  Unless the #define
++  REALLOC_ZERO_BYTES_FREES is set, realloc with a size argument of
++  zero (re)allocates a minimum-sized chunk.
++
++  Large chunks that were internally obtained via mmap will always
++  be reallocated using malloc-copy-free sequences unless
++  the system supports MREMAP (currently only linux).
++
++  The old unix realloc convention of allowing the last-free'd chunk
++  to be used as an argument to realloc is not supported.
++*/
++#if __STD_C
++Void_t*  public_rEALLOc(Void_t*, size_t);
++#else
++Void_t*  public_rEALLOc();
++#endif
++
++/*
++  memalign(size_t alignment, size_t n);
++  Returns a pointer to a newly allocated chunk of n bytes, aligned
++  in accord with the alignment argument.
++
++  The alignment argument should be a power of two. If the argument is
++  not a power of two, the nearest greater power is used.
++  8-byte alignment is guaranteed by normal malloc calls, so don't
++  bother calling memalign with an argument of 8 or less.
++
++  Overreliance on memalign is a sure way to fragment space.
++*/
++#if __STD_C
++Void_t*  public_mEMALIGn(size_t, size_t);
++#else
++Void_t*  public_mEMALIGn();
++#endif
++
++/*
++  valloc(size_t n);
++  Equivalent to memalign(pagesize, n), where pagesize is the page
++  size of the system. If the pagesize is unknown, 4096 is used.
++*/
++#if __STD_C
++Void_t*  public_vALLOc(size_t);
++#else
++Void_t*  public_vALLOc();
++#endif
++
++
++
++/*
++  mallopt(int parameter_number, int parameter_value)
++  Sets tunable parameters The format is to provide a
++  (parameter-number, parameter-value) pair.  mallopt then sets the
++  corresponding parameter to the argument value if it can (i.e., so
++  long as the value is meaningful), and returns 1 if successful else
++  0.  SVID/XPG/ANSI defines four standard param numbers for mallopt,
++  normally defined in malloc.h.  Only one of these (M_MXFAST) is used
++  in this malloc. The others (M_NLBLKS, M_GRAIN, M_KEEP) don't apply,
++  so setting them has no effect. But this malloc also supports four
++  other options in mallopt. See below for details.  Briefly, supported
++  parameters are as follows (listed defaults are for "typical"
++  configurations).
++
++  Symbol            param #   default    allowed param values
++  M_MXFAST          1         64         0-80  (0 disables fastbins)
++  M_TRIM_THRESHOLD -1         128*1024   any   (-1U disables trimming)
++  M_TOP_PAD        -2         0          any
++  M_MMAP_THRESHOLD -3         128*1024   any   (or 0 if no MMAP support)
++  M_MMAP_MAX       -4         65536      any   (0 disables use of mmap)
++*/
++#if __STD_C
++int      public_mALLOPt(int, int);
++#else
++int      public_mALLOPt();
++#endif
++
++
++/*
++  mallinfo()
++  Returns (by copy) a struct containing various summary statistics:
++
++  arena:     current total non-mmapped bytes allocated from system
++  ordblks:   the number of free chunks
++  smblks:    the number of fastbin blocks (i.e., small chunks that
++               have been freed but not use resused or consolidated)
++  hblks:     current number of mmapped regions
++  hblkhd:    total bytes held in mmapped regions
++  usmblks:   the maximum total allocated space. This will be greater
++                than current total if trimming has occurred.
++  fsmblks:   total bytes held in fastbin blocks
++  uordblks:  current total allocated space (normal or mmapped)
++  fordblks:  total free space
++  keepcost:  the maximum number of bytes that could ideally be released
++               back to system via malloc_trim. ("ideally" means that
++               it ignores page restrictions etc.)
++
++  Because these fields are ints, but internal bookkeeping may
++  be kept as longs, the reported values may wrap around zero and
++  thus be inaccurate.
++*/
++#if __STD_C
++struct mallinfo public_mALLINFo(void);
++#else
++struct mallinfo public_mALLINFo();
++#endif
++
++/*
++  independent_calloc(size_t n_elements, size_t element_size, Void_t* chunks[]);
++
++  independent_calloc is similar to calloc, but instead of returning a
++  single cleared space, it returns an array of pointers to n_elements
++  independent elements that can hold contents of size elem_size, each
++  of which starts out cleared, and can be independently freed,
++  realloc'ed etc. The elements are guaranteed to be adjacently
++  allocated (this is not guaranteed to occur with multiple callocs or
++  mallocs), which may also improve cache locality in some
++  applications.
++
++  The "chunks" argument is optional (i.e., may be null, which is
++  probably the most typical usage). If it is null, the returned array
++  is itself dynamically allocated and should also be freed when it is
++  no longer needed. Otherwise, the chunks array must be of at least
++  n_elements in length. It is filled in with the pointers to the
++  chunks.
++
++  In either case, independent_calloc returns this pointer array, or
++  null if the allocation failed.  If n_elements is zero and "chunks"
++  is null, it returns a chunk representing an array with zero elements
++  (which should be freed if not wanted).
++
++  Each element must be individually freed when it is no longer
++  needed. If you'd like to instead be able to free all at once, you
++  should instead use regular calloc and assign pointers into this
++  space to represent elements.  (In this case though, you cannot
++  independently free elements.)
++
++  independent_calloc simplifies and speeds up implementations of many
++  kinds of pools.  It may also be useful when constructing large data
++  structures that initially have a fixed number of fixed-sized nodes,
++  but the number is not known at compile time, and some of the nodes
++  may later need to be freed. For example:
++
++  struct Node { int item; struct Node* next; };
++
++  struct Node* build_list() {
++    struct Node** pool;
++    int n = read_number_of_nodes_needed();
++    if (n <= 0) return 0;
++    pool = (struct Node**)(independent_calloc(n, sizeof(struct Node), 0);
++    if (pool == 0) die();
++    // organize into a linked list...
++    struct Node* first = pool[0];
++    for (i = 0; i < n-1; ++i)
++      pool[i]->next = pool[i+1];
++    free(pool);     // Can now free the array (or not, if it is needed later)
++    return first;
++  }
++*/
++#if __STD_C
++Void_t** public_iCALLOc(size_t, size_t, Void_t**);
++#else
++Void_t** public_iCALLOc();
++#endif
++
++/*
++  independent_comalloc(size_t n_elements, size_t sizes[], Void_t* chunks[]);
++
++  independent_comalloc allocates, all at once, a set of n_elements
++  chunks with sizes indicated in the "sizes" array.    It returns
++  an array of pointers to these elements, each of which can be
++  independently freed, realloc'ed etc. The elements are guaranteed to
++  be adjacently allocated (this is not guaranteed to occur with
++  multiple callocs or mallocs), which may also improve cache locality
++  in some applications.
++
++  The "chunks" argument is optional (i.e., may be null). If it is null
++  the returned array is itself dynamically allocated and should also
++  be freed when it is no longer needed. Otherwise, the chunks array
++  must be of at least n_elements in length. It is filled in with the
++  pointers to the chunks.
++
++  In either case, independent_comalloc returns this pointer array, or
++  null if the allocation failed.  If n_elements is zero and chunks is
++  null, it returns a chunk representing an array with zero elements
++  (which should be freed if not wanted).
++
++  Each element must be individually freed when it is no longer
++  needed. If you'd like to instead be able to free all at once, you
++  should instead use a single regular malloc, and assign pointers at
++  particular offsets in the aggregate space. (In this case though, you
++  cannot independently free elements.)
++
++  independent_comallac differs from independent_calloc in that each
++  element may have a different size, and also that it does not
++  automatically clear elements.
++
++  independent_comalloc can be used to speed up allocation in cases
++  where several structs or objects must always be allocated at the
++  same time.  For example:
++
++  struct Head { ... }
++  struct Foot { ... }
++
++  void send_message(char* msg) {
++    int msglen = strlen(msg);
++    size_t sizes[3] = { sizeof(struct Head), msglen, sizeof(struct Foot) };
++    void* chunks[3];
++    if (independent_comalloc(3, sizes, chunks) == 0)
++      die();
++    struct Head* head = (struct Head*)(chunks[0]);
++    char*        body = (char*)(chunks[1]);
++    struct Foot* foot = (struct Foot*)(chunks[2]);
++    // ...
++  }
++
++  In general though, independent_comalloc is worth using only for
++  larger values of n_elements. For small values, you probably won't
++  detect enough difference from series of malloc calls to bother.
++
++  Overuse of independent_comalloc can increase overall memory usage,
++  since it cannot reuse existing noncontiguous small chunks that
++  might be available for some of the elements.
++*/
++#if __STD_C
++Void_t** public_iCOMALLOc(size_t, size_t*, Void_t**);
++#else
++Void_t** public_iCOMALLOc();
++#endif
++
++
++/*
++  pvalloc(size_t n);
++  Equivalent to valloc(minimum-page-that-holds(n)), that is,
++  round up n to nearest pagesize.
++ */
++#if __STD_C
++Void_t*  public_pVALLOc(size_t);
++#else
++Void_t*  public_pVALLOc();
++#endif
++
++/*
++  cfree(Void_t* p);
++  Equivalent to free(p).
++
++  cfree is needed/defined on some systems that pair it with calloc,
++  for odd historical reasons (such as: cfree is used in example
++  code in the first edition of K&R).
++*/
++#if __STD_C
++void     public_cFREe(Void_t*);
++#else
++void     public_cFREe();
++#endif
++
++/*
++  malloc_trim(size_t pad);
++
++  If possible, gives memory back to the system (via negative
++  arguments to sbrk) if there is unused memory at the `high' end of
++  the malloc pool. You can call this after freeing large blocks of
++  memory to potentially reduce the system-level memory requirements
++  of a program. However, it cannot guarantee to reduce memory. Under
++  some allocation patterns, some large free blocks of memory will be
++  locked between two used chunks, so they cannot be given back to
++  the system.
++
++  The `pad' argument to malloc_trim represents the amount of free
++  trailing space to leave untrimmed. If this argument is zero,
++  only the minimum amount of memory to maintain internal data
++  structures will be left (one page or less). Non-zero arguments
++  can be supplied to maintain enough trailing space to service
++  future expected allocations without having to re-obtain memory
++  from the system.
++
++  Malloc_trim returns 1 if it actually released any memory, else 0.
++  On systems that do not support "negative sbrks", it will always
++  rreturn 0.
++*/
++#if __STD_C
++int      public_mTRIm(size_t);
++#else
++int      public_mTRIm();
++#endif
++
++/*
++  malloc_usable_size(Void_t* p);
++
++  Returns the number of bytes you can actually use in
++  an allocated chunk, which may be more than you requested (although
++  often not) due to alignment and minimum size constraints.
++  You can use this many bytes without worrying about
++  overwriting other allocated objects. This is not a particularly great
++  programming practice. malloc_usable_size can be more useful in
++  debugging and assertions, for example:
++
++  p = malloc(n);
++  assert(malloc_usable_size(p) >= 256);
++
++*/
++#if __STD_C
++size_t   public_mUSABLe(Void_t*);
++#else
++size_t   public_mUSABLe();
++#endif
++
++/*
++  malloc_stats();
++  Prints on stderr the amount of space obtained from the system (both
++  via sbrk and mmap), the maximum amount (which may be more than
++  current if malloc_trim and/or munmap got called), and the current
++  number of bytes allocated via malloc (or realloc, etc) but not yet
++  freed. Note that this is the number of bytes allocated, not the
++  number requested. It will be larger than the number requested
++  because of alignment and bookkeeping overhead. Because it includes
++  alignment wastage as being in use, this figure may be greater than
++  zero even when no user-level chunks are allocated.
++
++  The reported current and maximum system memory can be inaccurate if
++  a program makes other calls to system memory allocation functions
++  (normally sbrk) outside of malloc.
++
++  malloc_stats prints only the most commonly interesting statistics.
++  More information can be obtained by calling mallinfo.
++
++*/
++#if __STD_C
++void     public_mSTATs();
++#else
++void     public_mSTATs();
++#endif
++
++/* mallopt tuning options */
++
++/*
++  M_MXFAST is the maximum request size used for "fastbins", special bins
++  that hold returned chunks without consolidating their spaces. This
++  enables future requests for chunks of the same size to be handled
++  very quickly, but can increase fragmentation, and thus increase the
++  overall memory footprint of a program.
++
++  This malloc manages fastbins very conservatively yet still
++  efficiently, so fragmentation is rarely a problem for values less
++  than or equal to the default.  The maximum supported value of MXFAST
++  is 80. You wouldn't want it any higher than this anyway.  Fastbins
++  are designed especially for use with many small structs, objects or
++  strings -- the default handles structs/objects/arrays with sizes up
++  to 8 4byte fields, or small strings representing words, tokens,
++  etc. Using fastbins for larger objects normally worsens
++  fragmentation without improving speed.
++
++  M_MXFAST is set in REQUEST size units. It is internally used in
++  chunksize units, which adds padding and alignment.  You can reduce
++  M_MXFAST to 0 to disable all use of fastbins.  This causes the malloc
++  algorithm to be a closer approximation of fifo-best-fit in all cases,
++  not just for larger requests, but will generally cause it to be
++  slower.
++*/
++
++
++/* M_MXFAST is a standard SVID/XPG tuning option, usually listed in malloc.h */
++#ifndef M_MXFAST
++#define M_MXFAST            1
++#endif
++
++#ifndef DEFAULT_MXFAST
++#define DEFAULT_MXFAST     64
++#endif
++
++
++/*
++  M_TRIM_THRESHOLD is the maximum amount of unused top-most memory
++  to keep before releasing via malloc_trim in free().
++
++  Automatic trimming is mainly useful in long-lived programs.
++  Because trimming via sbrk can be slow on some systems, and can
++  sometimes be wasteful (in cases where programs immediately
++  afterward allocate more large chunks) the value should be high
++  enough so that your overall system performance would improve by
++  releasing this much memory.
++
++  The trim threshold and the mmap control parameters (see below)
++  can be traded off with one another. Trimming and mmapping are
++  two different ways of releasing unused memory back to the
++  system. Between these two, it is often possible to keep
++  system-level demands of a long-lived program down to a bare
++  minimum. For example, in one test suite of sessions measuring
++  the XF86 X server on Linux, using a trim threshold of 128K and a
++  mmap threshold of 192K led to near-minimal long term resource
++  consumption.
++
++  If you are using this malloc in a long-lived program, it should
++  pay to experiment with these values.  As a rough guide, you
++  might set to a value close to the average size of a process
++  (program) running on your system.  Releasing this much memory
++  would allow such a process to run in memory.  Generally, it's
++  worth it to tune for trimming rather tham memory mapping when a
++  program undergoes phases where several large chunks are
++  allocated and released in ways that can reuse each other's
++  storage, perhaps mixed with phases where there are no such
++  chunks at all.  And in well-behaved long-lived programs,
++  controlling release of large blocks via trimming versus mapping
++  is usually faster.
++
++  However, in most programs, these parameters serve mainly as
++  protection against the system-level effects of carrying around
++  massive amounts of unneeded memory. Since frequent calls to
++  sbrk, mmap, and munmap otherwise degrade performance, the default
++  parameters are set to relatively high values that serve only as
++  safeguards.
++
++  The trim value It must be greater than page size to have any useful
++  effect.  To disable trimming completely, you can set to
++  (unsigned long)(-1)
++
++  Trim settings interact with fastbin (MXFAST) settings: Unless
++  TRIM_FASTBINS is defined, automatic trimming never takes place upon
++  freeing a chunk with size less than or equal to MXFAST. Trimming is
++  instead delayed until subsequent freeing of larger chunks. However,
++  you can still force an attempted trim by calling malloc_trim.
++
++  Also, trimming is not generally possible in cases where
++  the main arena is obtained via mmap.
++
++  Note that the trick some people use of mallocing a huge space and
++  then freeing it at program startup, in an attempt to reserve system
++  memory, doesn't have the intended effect under automatic trimming,
++  since that memory will immediately be returned to the system.
++*/
++
++#define M_TRIM_THRESHOLD       -1
++
++#ifndef DEFAULT_TRIM_THRESHOLD
++#define DEFAULT_TRIM_THRESHOLD (128 * 1024)
++#endif
++
++/*
++  M_TOP_PAD is the amount of extra `padding' space to allocate or
++  retain whenever sbrk is called. It is used in two ways internally:
++
++  * When sbrk is called to extend the top of the arena to satisfy
++  a new malloc request, this much padding is added to the sbrk
++  request.
++
++  * When malloc_trim is called automatically from free(),
++  it is used as the `pad' argument.
++
++  In both cases, the actual amount of padding is rounded
++  so that the end of the arena is always a system page boundary.
++
++  The main reason for using padding is to avoid calling sbrk so
++  often. Having even a small pad greatly reduces the likelihood
++  that nearly every malloc request during program start-up (or
++  after trimming) will invoke sbrk, which needlessly wastes
++  time.
++
++  Automatic rounding-up to page-size units is normally sufficient
++  to avoid measurable overhead, so the default is 0.  However, in
++  systems where sbrk is relatively slow, it can pay to increase
++  this value, at the expense of carrying around more memory than
++  the program needs.
++*/
++
++#define M_TOP_PAD              -2
++
++#ifndef DEFAULT_TOP_PAD
++#define DEFAULT_TOP_PAD        (0)
++#endif
++
++/*
++  M_MMAP_THRESHOLD is the request size threshold for using mmap()
++  to service a request. Requests of at least this size that cannot
++  be allocated using already-existing space will be serviced via mmap.
++  (If enough normal freed space already exists it is used instead.)
++
++  Using mmap segregates relatively large chunks of memory so that
++  they can be individually obtained and released from the host
++  system. A request serviced through mmap is never reused by any
++  other request (at least not directly; the system may just so
++  happen to remap successive requests to the same locations).
++
++  Segregating space in this way has the benefits that:
++
++   1. Mmapped space can ALWAYS be individually released back
++      to the system, which helps keep the system level memory
++      demands of a long-lived program low.
++   2. Mapped memory can never become `locked' between
++      other chunks, as can happen with normally allocated chunks, which
++      means that even trimming via malloc_trim would not release them.
++   3. On some systems with "holes" in address spaces, mmap can obtain
++      memory that sbrk cannot.
++
++  However, it has the disadvantages that:
++
++   1. The space cannot be reclaimed, consolidated, and then
++      used to service later requests, as happens with normal chunks.
++   2. It can lead to more wastage because of mmap page alignment
++      requirements
++   3. It causes malloc performance to be more dependent on host
++      system memory management support routines which may vary in
++      implementation quality and may impose arbitrary
++      limitations. Generally, servicing a request via normal
++      malloc steps is faster than going through a system's mmap.
++
++  The advantages of mmap nearly always outweigh disadvantages for
++  "large" chunks, but the value of "large" varies across systems.  The
++  default is an empirically derived value that works well in most
++  systems.
++*/
++
++#define M_MMAP_THRESHOLD      -3
++
++#ifndef DEFAULT_MMAP_THRESHOLD
++#define DEFAULT_MMAP_THRESHOLD (128 * 1024)
++#endif
++
++/*
++  M_MMAP_MAX is the maximum number of requests to simultaneously
++  service using mmap. This parameter exists because
++. Some systems have a limited number of internal tables for
++  use by mmap, and using more than a few of them may degrade
++  performance.
++
++  The default is set to a value that serves only as a safeguard.
++  Setting to 0 disables use of mmap for servicing large requests.  If
++  HAVE_MMAP is not set, the default value is 0, and attempts to set it
++  to non-zero values in mallopt will fail.
++*/
++
++#define M_MMAP_MAX             -4
++
++#ifndef DEFAULT_MMAP_MAX
++#if HAVE_MMAP
++#define DEFAULT_MMAP_MAX       (65536)
++#else
++#define DEFAULT_MMAP_MAX       (0)
++#endif
++#endif
++
++#ifdef __cplusplus
++};  /* end of extern "C" */
++#endif
++
++/*
++  ========================================================================
++  To make a fully customizable malloc.h header file, cut everything
++  above this line, put into file malloc.h, edit to suit, and #include it
++  on the next line, as well as in programs that use this malloc.
++  ========================================================================
++*/
++
++/* #include "malloc.h" */
++
++/* --------------------- public wrappers ---------------------- */
++
++#ifdef USE_PUBLIC_MALLOC_WRAPPERS
++
++/* Declare all routines as internal */
++#if __STD_C
++static Void_t*  mALLOc(size_t);
++static void     fREe(Void_t*);
++static Void_t*  rEALLOc(Void_t*, size_t);
++static Void_t*  mEMALIGn(size_t, size_t);
++static Void_t*  vALLOc(size_t);
++static Void_t*  pVALLOc(size_t);
++static Void_t*  cALLOc(size_t, size_t);
++static Void_t** iCALLOc(size_t, size_t, Void_t**);
++static Void_t** iCOMALLOc(size_t, size_t*, Void_t**);
++static void     cFREe(Void_t*);
++static int      mTRIm(size_t);
++static size_t   mUSABLe(Void_t*);
++static void     mSTATs();
++static int      mALLOPt(int, int);
++static struct mallinfo mALLINFo(void);
++#else
++static Void_t*  mALLOc();
++static void     fREe();
++static Void_t*  rEALLOc();
++static Void_t*  mEMALIGn();
++static Void_t*  vALLOc();
++static Void_t*  pVALLOc();
++static Void_t*  cALLOc();
++static Void_t** iCALLOc();
++static Void_t** iCOMALLOc();
++static void     cFREe();
++static int      mTRIm();
++static size_t   mUSABLe();
++static void     mSTATs();
++static int      mALLOPt();
++static struct mallinfo mALLINFo();
++#endif
++
++/*
++  MALLOC_PREACTION and MALLOC_POSTACTION should be
++  defined to return 0 on success, and nonzero on failure.
++  The return value of MALLOC_POSTACTION is currently ignored
++  in wrapper functions since there is no reasonable default
++  action to take on failure.
++*/
++
++
++#ifdef USE_MALLOC_LOCK
++
++#ifdef WIN32
++
++static int mALLOC_MUTEx;
++#define MALLOC_PREACTION   slwait(&mALLOC_MUTEx)
++#define MALLOC_POSTACTION  slrelease(&mALLOC_MUTEx)
++
++#else
++
++#if 0
++#include <pthread.h>
++
++static pthread_mutex_t mALLOC_MUTEx = PTHREAD_MUTEX_INITIALIZER;
++
++#define MALLOC_PREACTION   pthread_mutex_lock(&mALLOC_MUTEx)
++#define MALLOC_POSTACTION  pthread_mutex_unlock(&mALLOC_MUTEx)
++
++#else
++
++#ifdef KDE_MALLOC_X86
++#include "x86.h"
++#elif defined(KDE_MALLOC_AVR32)
++
++#include <sched.h>
++#include <time.h>
++
++static __inline__ int q_atomic_swp(volatile unsigned int *ptr,
++                                    unsigned int newval)
++{
++    register int ret;
++    asm volatile("xchg %0,%1,%2"
++                 : "=&r"(ret)
++                 : "r"(ptr), "r"(newval)
++                 : "memory", "cc");
++    return ret;
++}
++
++typedef struct {
++  volatile unsigned int lock;
++  int pad0_;
++} mutex_t;
++
++#define MUTEX_INITIALIZER          { 0, 0 }
++
++static __inline__ int lock(mutex_t *m) {
++  int cnt = 0;
++  struct timespec tm;
++
++  for(;;) {
++      if (q_atomic_swp(&m->lock, 1) == 0)
++          return 0;
++#ifdef _POSIX_PRIORITY_SCHEDULING
++    if(cnt < 50) {
++      sched_yield();
++      cnt++;
++    } else
++#endif
++        {
++      tm.tv_sec = 0;
++      tm.tv_nsec = 2000001;
++      nanosleep(&tm, NULL);
++      cnt = 0;
++    }
++  }
++}
++
++static __inline__ int unlock(mutex_t *m) {
++    m->lock = 0;
++    return 0;
++}
++
++#else
++#error Unknown spinlock implementation
++#endif
++
++static mutex_t spinlock = MUTEX_INITIALIZER;
++
++#define MALLOC_PREACTION   lock( &spinlock )
++#define MALLOC_POSTACTION  unlock( &spinlock )
++
++#endif
++
++#endif /* USE_MALLOC_LOCK */
++
++#else
++
++/* Substitute anything you like for these */
++
++#define MALLOC_PREACTION   (0)
++#define MALLOC_POSTACTION  (0)
++
++#endif
++
++#if 0
++Void_t* public_mALLOc(size_t bytes) {
++  Void_t* m;
++  if (MALLOC_PREACTION != 0) {
++    return 0;
++  }
++  m = mALLOc(bytes);
++  if (MALLOC_POSTACTION != 0) {
++  }
++  return m;
++}
++
++void public_fREe(Void_t* m) {
++  if (MALLOC_PREACTION != 0) {
++    return;
++  }
++  fREe(m);
++  if (MALLOC_POSTACTION != 0) {
++  }
++}
++
++Void_t* public_rEALLOc(Void_t* m, size_t bytes) {
++  if (MALLOC_PREACTION != 0) {
++    return 0;
++  }
++  m = rEALLOc(m, bytes);
++  if (MALLOC_POSTACTION != 0) {
++  }
++  return m;
++}
++
++Void_t* public_mEMALIGn(size_t alignment, size_t bytes) {
++  Void_t* m;
++  if (MALLOC_PREACTION != 0) {
++    return 0;
++  }
++  m = mEMALIGn(alignment, bytes);
++  if (MALLOC_POSTACTION != 0) {
++  }
++  return m;
++}
++
++Void_t* public_vALLOc(size_t bytes) {
++  Void_t* m;
++  if (MALLOC_PREACTION != 0) {
++    return 0;
++  }
++  m = vALLOc(bytes);
++  if (MALLOC_POSTACTION != 0) {
++  }
++  return m;
++}
++
++Void_t* public_pVALLOc(size_t bytes) {
++  Void_t* m;
++  if (MALLOC_PREACTION != 0) {
++    return 0;
++  }
++  m = pVALLOc(bytes);
++  if (MALLOC_POSTACTION != 0) {
++  }
++  return m;
++}
++
++Void_t* public_cALLOc(size_t n, size_t elem_size) {
++  Void_t* m;
++  if (MALLOC_PREACTION != 0) {
++    return 0;
++  }
++  m = cALLOc(n, elem_size);
++  if (MALLOC_POSTACTION != 0) {
++  }
++  return m;
++}
++
++
++Void_t** public_iCALLOc(size_t n, size_t elem_size, Void_t** chunks) {
++  Void_t** m;
++  if (MALLOC_PREACTION != 0) {
++    return 0;
++  }
++  m = iCALLOc(n, elem_size, chunks);
++  if (MALLOC_POSTACTION != 0) {
++  }
++  return m;
++}
++
++Void_t** public_iCOMALLOc(size_t n, size_t sizes[], Void_t** chunks) {
++  Void_t** m;
++  if (MALLOC_PREACTION != 0) {
++    return 0;
++  }
++  m = iCOMALLOc(n, sizes, chunks);
++  if (MALLOC_POSTACTION != 0) {
++  }
++  return m;
++}
++
++void public_cFREe(Void_t* m) {
++  if (MALLOC_PREACTION != 0) {
++    return;
++  }
++  cFREe(m);
++  if (MALLOC_POSTACTION != 0) {
++  }
++}
++
++int public_mTRIm(size_t s) {
++  int result;
++  if (MALLOC_PREACTION != 0) {
++    return 0;
++  }
++  result = mTRIm(s);
++  if (MALLOC_POSTACTION != 0) {
++  }
++  return result;
++}
++
++size_t public_mUSABLe(Void_t* m) {
++  size_t result;
++  if (MALLOC_PREACTION != 0) {
++    return 0;
++  }
++  result = mUSABLe(m);
++  if (MALLOC_POSTACTION != 0) {
++  }
++  return result;
++}
++
++void public_mSTATs() {
++  if (MALLOC_PREACTION != 0) {
++    return;
++  }
++  mSTATs();
++  if (MALLOC_POSTACTION != 0) {
++  }
++}
++
++struct mallinfo public_mALLINFo() {
++  struct mallinfo m;
++  if (MALLOC_PREACTION != 0) {
++    struct mallinfo nm = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
++    return nm;
++  }
++  m = mALLINFo();
++  if (MALLOC_POSTACTION != 0) {
++  }
++  return m;
++}
++
++int public_mALLOPt(int p, int v) {
++  int result;
++  if (MALLOC_PREACTION != 0) {
++    return 0;
++  }
++  result = mALLOPt(p, v);
++  if (MALLOC_POSTACTION != 0) {
++  }
++  return result;
++}
++#endif
++
++#endif
++
++
++
++/* ------------- Optional versions of memcopy ---------------- */
++
++
++#if USE_MEMCPY
++
++/*
++  Note: memcpy is ONLY invoked with non-overlapping regions,
++  so the (usually slower) memmove is not needed.
++*/
++
++#define MALLOC_COPY(dest, src, nbytes)  memcpy(dest, src, nbytes)
++#define MALLOC_ZERO(dest, nbytes)       memset(dest, 0,   nbytes)
++
++#else /* !USE_MEMCPY */
++
++/* Use Duff's device for good zeroing/copying performance. */
++
++#define MALLOC_ZERO(charp, nbytes)                                            \
++do {                                                                          \
++  INTERNAL_SIZE_T* mzp = (INTERNAL_SIZE_T*)(charp);                           \
++  unsigned long mctmp = (nbytes)/sizeof(INTERNAL_SIZE_T);                     \
++  long mcn;                                                                   \
++  if (mctmp < 8) mcn = 0; else { mcn = (mctmp-1)/8; mctmp %= 8; }             \
++  switch (mctmp) {                                                            \
++    case 0: for(;;) { *mzp++ = 0;                                             \
++    case 7:           *mzp++ = 0;                                             \
++    case 6:           *mzp++ = 0;                                             \
++    case 5:           *mzp++ = 0;                                             \
++    case 4:           *mzp++ = 0;                                             \
++    case 3:           *mzp++ = 0;                                             \
++    case 2:           *mzp++ = 0;                                             \
++    case 1:           *mzp++ = 0; if(mcn <= 0) break; mcn--; }                \
++  }                                                                           \
++} while(0)
++
++#define MALLOC_COPY(dest,src,nbytes)                                          \
++do {                                                                          \
++  INTERNAL_SIZE_T* mcsrc = (INTERNAL_SIZE_T*) src;                            \
++  INTERNAL_SIZE_T* mcdst = (INTERNAL_SIZE_T*) dest;                           \
++  unsigned long mctmp = (nbytes)/sizeof(INTERNAL_SIZE_T);                     \
++  long mcn;                                                                   \
++  if (mctmp < 8) mcn = 0; else { mcn = (mctmp-1)/8; mctmp %= 8; }             \
++  switch (mctmp) {                                                            \
++    case 0: for(;;) { *mcdst++ = *mcsrc++;                                    \
++    case 7:           *mcdst++ = *mcsrc++;                                    \
++    case 6:           *mcdst++ = *mcsrc++;                                    \
++    case 5:           *mcdst++ = *mcsrc++;                                    \
++    case 4:           *mcdst++ = *mcsrc++;                                    \
++    case 3:           *mcdst++ = *mcsrc++;                                    \
++    case 2:           *mcdst++ = *mcsrc++;                                    \
++    case 1:           *mcdst++ = *mcsrc++; if(mcn <= 0) break; mcn--; }       \
++  }                                                                           \
++} while(0)
++
++#endif
++
++/* ------------------ MMAP support ------------------  */
++
++
++#if HAVE_MMAP
++
++#include <fcntl.h>
++#ifndef LACKS_SYS_MMAN_H
++#include <sys/mman.h>
++#endif
++
++#if !defined(MAP_ANONYMOUS) && defined(MAP_ANON)
++#define MAP_ANONYMOUS MAP_ANON
++#endif
++
++/*
++   Nearly all versions of mmap support MAP_ANONYMOUS,
++   so the following is unlikely to be needed, but is
++   supplied just in case.
++*/
++
++#ifndef MAP_ANONYMOUS
++
++static int dev_zero_fd = -1; /* Cached file descriptor for /dev/zero. */
++
++#define MMAP(addr, size, prot, flags) ((dev_zero_fd < 0) ? \
++ (dev_zero_fd = open("/dev/zero", O_RDWR), \
++  mmap((addr), (size), (prot), (flags), dev_zero_fd, 0)) : \
++   mmap((addr), (size), (prot), (flags), dev_zero_fd, 0))
++
++#else
++
++#define MMAP(addr, size, prot, flags) \
++ (mmap((addr), (size), (prot), (flags)|MAP_ANONYMOUS, -1, 0))
++
++#endif
++
++
++#endif /* HAVE_MMAP */
++
++
++/*
++  -----------------------  Chunk representations -----------------------
++*/
++
++
++/*
++  This struct declaration is misleading (but accurate and necessary).
++  It declares a "view" into memory allowing access to necessary
++  fields at known offsets from a given base. See explanation below.
++*/
++
++struct malloc_chunk {
++
++  INTERNAL_SIZE_T      prev_size;  /* Size of previous chunk (if free).  */
++  INTERNAL_SIZE_T      size;       /* Size in bytes, including overhead. */
++
++  struct malloc_chunk* fd;         /* double links -- used only if free. */
++  struct malloc_chunk* bk;
++};
++
++
++typedef struct malloc_chunk* mchunkptr;
++
++/*
++   malloc_chunk details:
++
++    (The following includes lightly edited explanations by Colin Plumb.)
++
++    Chunks of memory are maintained using a `boundary tag' method as
++    described in e.g., Knuth or Standish.  (See the paper by Paul
++    Wilson ftp://ftp.cs.utexas.edu/pub/garbage/allocsrv.ps for a
++    survey of such techniques.)  Sizes of free chunks are stored both
++    in the front of each chunk and at the end.  This makes
++    consolidating fragmented chunks into bigger chunks very fast.  The
++    size fields also hold bits representing whether chunks are free or
++    in use.
++
++    An allocated chunk looks like this:
++
++
++    chunk-> +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
++            |             Size of previous chunk, if allocated            | |
++            +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
++            |             Size of chunk, in bytes                         |P|
++      mem-> +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
++            |             User data starts here...                          .
++            .                                                               .
++            .             (malloc_usable_space() bytes)                     .
++            .                                                               |
++nextchunk-> +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
++            |             Size of chunk                                     |
++            +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
++
++
++    Where "chunk" is the front of the chunk for the purpose of most of
++    the malloc code, but "mem" is the pointer that is returned to the
++    user.  "Nextchunk" is the beginning of the next contiguous chunk.
++
++    Chunks always begin on even word boundaries, so the mem portion
++    (which is returned to the user) is also on an even word boundary, and
++    thus at least double-word aligned.
++
++    Free chunks are stored in circular doubly-linked lists, and look like this:
++
++    chunk-> +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
++            |             Size of previous chunk                            |
++            +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
++    `head:' |             Size of chunk, in bytes                         |P|
++      mem-> +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
++            |             Forward pointer to next chunk in list             |
++            +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
++            |             Back pointer to previous chunk in list            |
++            +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
++            |             Unused space (may be 0 bytes long)                .
++            .                                                               .
++            .                                                               |
++nextchunk-> +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
++    `foot:' |             Size of chunk, in bytes                           |
++            +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
++
++    The P (PREV_INUSE) bit, stored in the unused low-order bit of the
++    chunk size (which is always a multiple of two words), is an in-use
++    bit for the *previous* chunk.  If that bit is *clear*, then the
++    word before the current chunk size contains the previous chunk
++    size, and can be used to find the front of the previous chunk.
++    The very first chunk allocated always has this bit set,
++    preventing access to non-existent (or non-owned) memory. If
++    prev_inuse is set for any given chunk, then you CANNOT determine
++    the size of the previous chunk, and might even get a memory
++    addressing fault when trying to do so.
++
++    Note that the `foot' of the current chunk is actually represented
++    as the prev_size of the NEXT chunk. This makes it easier to
++    deal with alignments etc but can be very confusing when trying
++    to extend or adapt this code.
++
++    The two exceptions to all this are
++
++     1. The special chunk `top' doesn't bother using the
++        trailing size field since there is no next contiguous chunk
++        that would have to index off it. After initialization, `top'
++        is forced to always exist.  If it would become less than
++        MINSIZE bytes long, it is replenished.
++
++     2. Chunks allocated via mmap, which have the second-lowest-order
++        bit (IS_MMAPPED) set in their size fields.  Because they are
++        allocated one-by-one, each must contain its own trailing size field.
++
++*/
++
++/*
++  ---------- Size and alignment checks and conversions ----------
++*/
++
++/* conversion from malloc headers to user pointers, and back */
++
++#define chunk2mem(p)   ((Void_t*)((char*)(p) + 2*SIZE_SZ))
++#define mem2chunk(mem) ((mchunkptr)((char*)(mem) - 2*SIZE_SZ))
++
++/* The smallest possible chunk */
++#define MIN_CHUNK_SIZE        (sizeof(struct malloc_chunk))
++
++/* The smallest size we can malloc is an aligned minimal chunk */
++
++#define MINSIZE  \
++  (unsigned long)(((MIN_CHUNK_SIZE+MALLOC_ALIGN_MASK) & ~MALLOC_ALIGN_MASK))
++
++/* Check if m has acceptable alignment */
++
++#define aligned_OK(m)  (((unsigned long)((m)) & (MALLOC_ALIGN_MASK)) == 0)
++
++
++/*
++   Check if a request is so large that it would wrap around zero when
++   padded and aligned. To simplify some other code, the bound is made
++   low enough so that adding MINSIZE will also not wrap around zero.
++*/
++
++#define REQUEST_OUT_OF_RANGE(req)                                 \
++  ((unsigned long)(req) >=                                        \
++   (unsigned long)(INTERNAL_SIZE_T)(-2 * MINSIZE))
++
++/* pad request bytes into a usable size -- internal version */
++
++#define request2size(req)                                         \
++  (((req) + SIZE_SZ + MALLOC_ALIGN_MASK < MINSIZE)  ?             \
++   MINSIZE :                                                      \
++   ((req) + SIZE_SZ + MALLOC_ALIGN_MASK) & ~MALLOC_ALIGN_MASK)
++
++/*  Same, except also perform argument check */
++
++#define checked_request2size(req, sz)                             \
++  if (REQUEST_OUT_OF_RANGE(req)) {                                \
++    MALLOC_FAILURE_ACTION;                                        \
++    return 0;                                                     \
++  }                                                               \
++  (sz) = request2size(req);
++
++/*
++  --------------- Physical chunk operations ---------------
++*/
++
++
++/* size field is or'ed with PREV_INUSE when previous adjacent chunk in use */
++#define PREV_INUSE 0x1
++
++/* extract inuse bit of previous chunk */
++#define prev_inuse(p)       ((p)->size & PREV_INUSE)
++
++
++/* size field is or'ed with IS_MMAPPED if the chunk was obtained with mmap() */
++#define IS_MMAPPED 0x2
++
++/* check for mmap()'ed chunk */
++#define chunk_is_mmapped(p) ((p)->size & IS_MMAPPED)
++
++/*
++  Bits to mask off when extracting size
++
++  Note: IS_MMAPPED is intentionally not masked off from size field in
++  macros for which mmapped chunks should never be seen. This should
++  cause helpful core dumps to occur if it is tried by accident by
++  people extending or adapting this malloc.
++*/
++#define SIZE_BITS (PREV_INUSE|IS_MMAPPED)
++
++/* Get size, ignoring use bits */
++#define chunksize(p)         ((p)->size & ~(SIZE_BITS))
++
++
++/* Ptr to next physical malloc_chunk. */
++#define next_chunk(p) ((mchunkptr)( ((char*)(p)) + ((p)->size & ~PREV_INUSE) ))
++
++/* Ptr to previous physical malloc_chunk */
++#define prev_chunk(p) ((mchunkptr)( ((char*)(p)) - ((p)->prev_size) ))
++
++/* Treat space at ptr + offset as a chunk */
++#define chunk_at_offset(p, s)  ((mchunkptr)(((char*)(p)) + (s)))
++
++/* extract p's inuse bit */
++#define inuse(p)\
++((((mchunkptr)(((char*)(p))+((p)->size & ~PREV_INUSE)))->size) & PREV_INUSE)
++
++/* set/clear chunk as being inuse without otherwise disturbing */
++#define set_inuse(p)\
++((mchunkptr)(((char*)(p)) + ((p)->size & ~PREV_INUSE)))->size |= PREV_INUSE
++
++#define clear_inuse(p)\
++((mchunkptr)(((char*)(p)) + ((p)->size & ~PREV_INUSE)))->size &= ~(PREV_INUSE)
++
++
++/* check/set/clear inuse bits in known places */
++#define inuse_bit_at_offset(p, s)\
++ (((mchunkptr)(((char*)(p)) + (s)))->size & PREV_INUSE)
++
++#define set_inuse_bit_at_offset(p, s)\
++ (((mchunkptr)(((char*)(p)) + (s)))->size |= PREV_INUSE)
++
++#define clear_inuse_bit_at_offset(p, s)\
++ (((mchunkptr)(((char*)(p)) + (s)))->size &= ~(PREV_INUSE))
++
++
++/* Set size at head, without disturbing its use bit */
++#define set_head_size(p, s)  ((p)->size = (((p)->size & PREV_INUSE) | (s)))
++
++/* Set size/use field */
++#define set_head(p, s)       ((p)->size = (s))
++
++/* Set size at footer (only when chunk is not in use) */
++#define set_foot(p, s)       (((mchunkptr)((char*)(p) + (s)))->prev_size = (s))
++
++
++/*
++  -------------------- Internal data structures --------------------
++
++   All internal state is held in an instance of malloc_state defined
++   below. There are no other static variables, except in two optional
++   cases:
++   * If USE_MALLOC_LOCK is defined, the mALLOC_MUTEx declared above.
++   * If HAVE_MMAP is true, but mmap doesn't support
++     MAP_ANONYMOUS, a dummy file descriptor for mmap.
++
++   Beware of lots of tricks that minimize the total bookkeeping space
++   requirements. The result is a little over 1K bytes (for 4byte
++   pointers and size_t.)
++*/
++
++/*
++  Bins
++
++    An array of bin headers for free chunks. Each bin is doubly
++    linked.  The bins are approximately proportionally (log) spaced.
++    There are a lot of these bins (128). This may look excessive, but
++    works very well in practice.  Most bins hold sizes that are
++    unusual as malloc request sizes, but are more usual for fragments
++    and consolidated sets of chunks, which is what these bins hold, so
++    they can be found quickly.  All procedures maintain the invariant
++    that no consolidated chunk physically borders another one, so each
++    chunk in a list is known to be preceded and followed by either
++    inuse chunks or the ends of memory.
++
++    Chunks in bins are kept in size order, with ties going to the
++    approximately least recently used chunk. Ordering isn't needed
++    for the small bins, which all contain the same-sized chunks, but
++    facilitates best-fit allocation for larger chunks. These lists
++    are just sequential. Keeping them in order almost never requires
++    enough traversal to warrant using fancier ordered data
++    structures.
++
++    Chunks of the same size are linked with the most
++    recently freed at the front, and allocations are taken from the
++    back.  This results in LRU (FIFO) allocation order, which tends
++    to give each chunk an equal opportunity to be consolidated with
++    adjacent freed chunks, resulting in larger free chunks and less
++    fragmentation.
++
++    To simplify use in double-linked lists, each bin header acts
++    as a malloc_chunk. This avoids special-casing for headers.
++    But to conserve space and improve locality, we allocate
++    only the fd/bk pointers of bins, and then use repositioning tricks
++    to treat these as the fields of a malloc_chunk*.
++*/
++
++typedef struct malloc_chunk* mbinptr;
++
++/* addressing -- note that bin_at(0) does not exist */
++#define bin_at(m, i) ((mbinptr)((char*)&((m)->bins[(i)<<1]) - (SIZE_SZ<<1)))
++
++/* analog of ++bin */
++#define next_bin(b)  ((mbinptr)((char*)(b) + (sizeof(mchunkptr)<<1)))
++
++/* Reminders about list directionality within bins */
++#define first(b)     ((b)->fd)
++#define last(b)      ((b)->bk)
++
++/* Take a chunk off a bin list */
++#define unlink(P, BK, FD) {                                            \
++  FD = P->fd;                                                          \
++  BK = P->bk;                                                          \
++  FD->bk = BK;                                                         \
++  BK->fd = FD;                                                         \
++}
++
++/*
++  Indexing
++
++    Bins for sizes < 512 bytes contain chunks of all the same size, spaced
++    8 bytes apart. Larger bins are approximately logarithmically spaced:
++
++    64 bins of size       8
++    32 bins of size      64
++    16 bins of size     512
++     8 bins of size    4096
++     4 bins of size   32768
++     2 bins of size  262144
++     1 bin  of size what's left
++
++    There is actually a little bit of slop in the numbers in bin_index
++    for the sake of speed. This makes no difference elsewhere.
++
++    The bins top out around 1MB because we expect to service large
++    requests via mmap.
++*/
++
++#define NBINS             128
++#define NSMALLBINS         64
++#define SMALLBIN_WIDTH      8
++#define MIN_LARGE_SIZE    512
++
++#define in_smallbin_range(sz)  \
++  ((unsigned long)(sz) < (unsigned long)MIN_LARGE_SIZE)
++
++#define smallbin_index(sz)     (((unsigned)(sz)) >> 3)
++
++#define largebin_index(sz)                                                   \
++(((((unsigned long)(sz)) >>  6) <= 32)?  56 + (((unsigned long)(sz)) >>  6): \
++ ((((unsigned long)(sz)) >>  9) <= 20)?  91 + (((unsigned long)(sz)) >>  9): \
++ ((((unsigned long)(sz)) >> 12) <= 10)? 110 + (((unsigned long)(sz)) >> 12): \
++ ((((unsigned long)(sz)) >> 15) <=  4)? 119 + (((unsigned long)(sz)) >> 15): \
++ ((((unsigned long)(sz)) >> 18) <=  2)? 124 + (((unsigned long)(sz)) >> 18): \
++                                        126)
++
++#define bin_index(sz) \
++ ((in_smallbin_range(sz)) ? smallbin_index(sz) : largebin_index(sz))
++
++
++/*
++  Unsorted chunks
++
++    All remainders from chunk splits, as well as all returned chunks,
++    are first placed in the "unsorted" bin. They are then placed
++    in regular bins after malloc gives them ONE chance to be used before
++    binning. So, basically, the unsorted_chunks list acts as a queue,
++    with chunks being placed on it in free (and malloc_consolidate),
++    and taken off (to be either used or placed in bins) in malloc.
++*/
++
++/* The otherwise unindexable 1-bin is used to hold unsorted chunks. */
++#define unsorted_chunks(M)          (bin_at(M, 1))
++
++/*
++  Top
++
++    The top-most available chunk (i.e., the one bordering the end of
++    available memory) is treated specially. It is never included in
++    any bin, is used only if no other chunk is available, and is
++    released back to the system if it is very large (see
++    M_TRIM_THRESHOLD).  Because top initially
++    points to its own bin with initial zero size, thus forcing
++    extension on the first malloc request, we avoid having any special
++    code in malloc to check whether it even exists yet. But we still
++    need to do so when getting memory from system, so we make
++    initial_top treat the bin as a legal but unusable chunk during the
++    interval between initialization and the first call to
++    sYSMALLOc. (This is somewhat delicate, since it relies on
++    the 2 preceding words to be zero during this interval as well.)
++*/
++
++/* Conveniently, the unsorted bin can be used as dummy top on first call */
++#define initial_top(M)              (unsorted_chunks(M))
++
++/*
++  Binmap
++
++    To help compensate for the large number of bins, a one-level index
++    structure is used for bin-by-bin searching.  `binmap' is a
++    bitvector recording whether bins are definitely empty so they can
++    be skipped over during during traversals.  The bits are NOT always
++    cleared as soon as bins are empty, but instead only
++    when they are noticed to be empty during traversal in malloc.
++*/
++
++/* Conservatively use 32 bits per map word, even if on 64bit system */
++#define BINMAPSHIFT      5
++#define BITSPERMAP       (1U << BINMAPSHIFT)
++#define BINMAPSIZE       (NBINS / BITSPERMAP)
++
++#define idx2block(i)     ((i) >> BINMAPSHIFT)
++#define idx2bit(i)       ((1U << ((i) & ((1U << BINMAPSHIFT)-1))))
++
++#define mark_bin(m,i)    ((m)->binmap[idx2block(i)] |=  idx2bit(i))
++#define unmark_bin(m,i)  ((m)->binmap[idx2block(i)] &= ~(idx2bit(i)))
++#define get_binmap(m,i)  ((m)->binmap[idx2block(i)] &   idx2bit(i))
++
++/*
++  Fastbins
++
++    An array of lists holding recently freed small chunks.  Fastbins
++    are not doubly linked.  It is faster to single-link them, and
++    since chunks are never removed from the middles of these lists,
++    double linking is not necessary. Also, unlike regular bins, they
++    are not even processed in FIFO order (they use faster LIFO) since
++    ordering doesn't much matter in the transient contexts in which
++    fastbins are normally used.
++
++    Chunks in fastbins keep their inuse bit set, so they cannot
++    be consolidated with other free chunks. malloc_consolidate
++    releases all chunks in fastbins and consolidates them with
++    other free chunks.
++*/
++
++typedef struct malloc_chunk* mfastbinptr;
++
++/* offset 2 to use otherwise unindexable first 2 bins */
++#define fastbin_index(sz)        ((((unsigned int)(sz)) >> 3) - 2)
++
++/* The maximum fastbin request size we support */
++#define MAX_FAST_SIZE     80
++
++#define NFASTBINS  (fastbin_index(request2size(MAX_FAST_SIZE))+1)
++
++/*
++  FASTBIN_CONSOLIDATION_THRESHOLD is the size of a chunk in free()
++  that triggers automatic consolidation of possibly-surrounding
++  fastbin chunks. This is a heuristic, so the exact value should not
++  matter too much. It is defined at half the default trim threshold as a
++  compromise heuristic to only attempt consolidation if it is likely
++  to lead to trimming. However, it is not dynamically tunable, since
++  consolidation reduces fragmentation surrounding loarge chunks even
++  if trimming is not used.
++*/
++
++#define FASTBIN_CONSOLIDATION_THRESHOLD  (65536UL)
++
++/*
++  Since the lowest 2 bits in max_fast don't matter in size comparisons,
++  they are used as flags.
++*/
++
++/*
++  FASTCHUNKS_BIT held in max_fast indicates that there are probably
++  some fastbin chunks. It is set true on entering a chunk into any
++  fastbin, and cleared only in malloc_consolidate.
++
++  The truth value is inverted so that have_fastchunks will be true
++  upon startup (since statics are zero-filled), simplifying
++  initialization checks.
++*/
++
++#define FASTCHUNKS_BIT        (1U)
++
++#define have_fastchunks(M)     (((M)->max_fast &  FASTCHUNKS_BIT) == 0)
++#define clear_fastchunks(M)    ((M)->max_fast |=  FASTCHUNKS_BIT)
++#define set_fastchunks(M)      ((M)->max_fast &= ~FASTCHUNKS_BIT)
++
++/*
++  NONCONTIGUOUS_BIT indicates that MORECORE does not return contiguous
++  regions.  Otherwise, contiguity is exploited in merging together,
++  when possible, results from consecutive MORECORE calls.
++
++  The initial value comes from MORECORE_CONTIGUOUS, but is
++  changed dynamically if mmap is ever used as an sbrk substitute.
++*/
++
++#define NONCONTIGUOUS_BIT     (2U)
++
++#define contiguous(M)          (((M)->max_fast &  NONCONTIGUOUS_BIT) == 0)
++#define noncontiguous(M)       (((M)->max_fast &  NONCONTIGUOUS_BIT) != 0)
++#define set_noncontiguous(M)   ((M)->max_fast |=  NONCONTIGUOUS_BIT)
++#define set_contiguous(M)      ((M)->max_fast &= ~NONCONTIGUOUS_BIT)
++
++/*
++   Set value of max_fast.
++   Use impossibly small value if 0.
++   Precondition: there are no existing fastbin chunks.
++   Setting the value clears fastchunk bit but preserves noncontiguous bit.
++*/
++
++#define set_max_fast(M, s) \
++  (M)->max_fast = (((s) == 0)? SMALLBIN_WIDTH: request2size(s)) | \
++  FASTCHUNKS_BIT | \
++  ((M)->max_fast &  NONCONTIGUOUS_BIT)
++
++
++/*
++   ----------- Internal state representation and initialization -----------
++*/
++
++struct malloc_state {
++
++  /* The maximum chunk size to be eligible for fastbin */
++  INTERNAL_SIZE_T  max_fast;   /* low 2 bits used as flags */
++
++  /* Fastbins */
++  mfastbinptr      fastbins[NFASTBINS];
++
++  /* Base of the topmost chunk -- not otherwise kept in a bin */
++  mchunkptr        top;
++
++  /* The remainder from the most recent split of a small request */
++  mchunkptr        last_remainder;
++
++  /* Normal bins packed as described above */
++  mchunkptr        bins[NBINS * 2];
++
++  /* Bitmap of bins */
++  unsigned int     binmap[BINMAPSIZE];
++
++  /* Tunable parameters */
++  unsigned long    trim_threshold;
++  INTERNAL_SIZE_T  top_pad;
++  INTERNAL_SIZE_T  mmap_threshold;
++
++  /* Memory map support */
++  int              n_mmaps;
++  int              n_mmaps_max;
++  int              max_n_mmaps;
++
++  /* Cache malloc_getpagesize */
++  unsigned int     pagesize;
++
++  /* Statistics */
++  INTERNAL_SIZE_T  mmapped_mem;
++  INTERNAL_SIZE_T  sbrked_mem;
++  INTERNAL_SIZE_T  max_sbrked_mem;
++  INTERNAL_SIZE_T  max_mmapped_mem;
++  INTERNAL_SIZE_T  max_total_mem;
++};
++
++typedef struct malloc_state *mstate;
++
++/*
++   There is exactly one instance of this struct in this malloc.
++   If you are adapting this malloc in a way that does NOT use a static
++   malloc_state, you MUST explicitly zero-fill it before using. This
++   malloc relies on the property that malloc_state is initialized to
++   all zeroes (as is true of C statics).
++*/
++
++static struct malloc_state av_;  /* never directly referenced */
++
++/*
++   All uses of av_ are via get_malloc_state().
++   At most one "call" to get_malloc_state is made per invocation of
++   the public versions of malloc and free, but other routines
++   that in turn invoke malloc and/or free may call more then once.
++   Also, it is called in check* routines if DEBUG is set.
++*/
++
++#define get_malloc_state() (&(av_))
++
++/*
++  Initialize a malloc_state struct.
++
++  This is called only from within malloc_consolidate, which needs
++  be called in the same contexts anyway.  It is never called directly
++  outside of malloc_consolidate because some optimizing compilers try
++  to inline it at all call points, which turns out not to be an
++  optimization at all. (Inlining it in malloc_consolidate is fine though.)
++*/
++
++#if __STD_C
++static void malloc_init_state(mstate av)
++#else
++static void malloc_init_state(av) mstate av;
++#endif
++{
++  int     i;
++  mbinptr bin;
++
++  /* Establish circular links for normal bins */
++  for (i = 1; i < NBINS; ++i) {
++    bin = bin_at(av,i);
++    bin->fd = bin->bk = bin;
++  }
++
++  av->top_pad        = DEFAULT_TOP_PAD;
++  av->n_mmaps_max    = DEFAULT_MMAP_MAX;
++  av->mmap_threshold = DEFAULT_MMAP_THRESHOLD;
++  av->trim_threshold = DEFAULT_TRIM_THRESHOLD;
++
++#if !MORECORE_CONTIGUOUS
++  set_noncontiguous(av);
++#endif
++
++  set_max_fast(av, DEFAULT_MXFAST);
++
++  av->top            = initial_top(av);
++  av->pagesize       = malloc_getpagesize;
++}
++
++/*
++   Other internal utilities operating on mstates
++*/
++
++#if __STD_C
++static Void_t*  sYSMALLOc(INTERNAL_SIZE_T, mstate);
++static int      sYSTRIm(size_t, mstate);
++static void     malloc_consolidate(mstate);
++static Void_t** iALLOc(size_t, size_t*, int, Void_t**);
++#else
++static Void_t*  sYSMALLOc();
++static int      sYSTRIm();
++static void     malloc_consolidate();
++static Void_t** iALLOc();
++#endif
++
++/*
++  Debugging support
++
++  These routines make a number of assertions about the states
++  of data structures that should be true at all times. If any
++  are not true, it's very likely that a user program has somehow
++  trashed memory. (It's also possible that there is a coding error
++  in malloc. In which case, please report it!)
++*/
++
++#ifndef DEBUG
++
++#define check_chunk(P)
++#define check_free_chunk(P)
++#define check_inuse_chunk(P)
++#define check_remalloced_chunk(P,N)
++#define check_malloced_chunk(P,N)
++#define check_malloc_state()
++
++#else
++#define check_chunk(P)              do_check_chunk(P)
++#define check_free_chunk(P)         do_check_free_chunk(P)
++#define check_inuse_chunk(P)        do_check_inuse_chunk(P)
++#define check_remalloced_chunk(P,N) do_check_remalloced_chunk(P,N)
++#define check_malloced_chunk(P,N)   do_check_malloced_chunk(P,N)
++#define check_malloc_state()        do_check_malloc_state()
++
++/*
++  Properties of all chunks
++*/
++
++INLINE
++#if __STD_C
++static void do_check_chunk(mchunkptr p)
++#else
++static void do_check_chunk(p) mchunkptr p;
++#endif
++{
++  mstate av = get_malloc_state();
++  unsigned long sz = chunksize(p);
++  /* min and max possible addresses assuming contiguous allocation */
++  char* max_address = (char*)(av->top) + chunksize(av->top);
++  char* min_address = max_address - av->sbrked_mem;
++
++  if (!chunk_is_mmapped(p)) {
++
++    /* Has legal address ... */
++    if (p != av->top) {
++      if (contiguous(av)) {
++        assert(((char*)p) >= min_address);
++        assert(((char*)p + sz) <= ((char*)(av->top)));
++      }
++    }
++    else {
++      /* top size is always at least MINSIZE */
++      assert((unsigned long)(sz) >= MINSIZE);
++      /* top predecessor always marked inuse */
++      assert(prev_inuse(p));
++    }
++
++  }
++  else {
++#if HAVE_MMAP
++    /* address is outside main heap  */
++    if (contiguous(av) && av->top != initial_top(av)) {
++      assert(((char*)p) < min_address || ((char*)p) > max_address);
++    }
++    /* chunk is page-aligned */
++    assert(((p->prev_size + sz) & (av->pagesize-1)) == 0);
++    /* mem is aligned */
++    assert(aligned_OK(chunk2mem(p)));
++#else
++    /* force an appropriate assert violation if debug set */
++    assert(!chunk_is_mmapped(p));
++#endif
++  }
++}
++
++/*
++  Properties of free chunks
++*/
++
++INLINE
++#if __STD_C
++static void do_check_free_chunk(mchunkptr p)
++#else
++static void do_check_free_chunk(p) mchunkptr p;
++#endif
++{
++  mstate av = get_malloc_state();
++
++  INTERNAL_SIZE_T sz = p->size & ~PREV_INUSE;
++  mchunkptr next = chunk_at_offset(p, sz);
++
++  do_check_chunk(p);
++
++  /* Chunk must claim to be free ... */
++  assert(!inuse(p));
++  assert (!chunk_is_mmapped(p));
++
++  /* Unless a special marker, must have OK fields */
++  if ((unsigned long)(sz) >= MINSIZE)
++  {
++    assert((sz & MALLOC_ALIGN_MASK) == 0);
++    assert(aligned_OK(chunk2mem(p)));
++    /* ... matching footer field */
++    assert(next->prev_size == sz);
++    /* ... and is fully consolidated */
++    assert(prev_inuse(p));
++    assert (next == av->top || inuse(next));
++
++    /* ... and has minimally sane links */
++    assert(p->fd->bk == p);
++    assert(p->bk->fd == p);
++  }
++  else /* markers are always of size SIZE_SZ */
++    assert(sz == SIZE_SZ);
++}
++
++/*
++  Properties of inuse chunks
++*/
++
++INLINE
++#if __STD_C
++static void do_check_inuse_chunk(mchunkptr p)
++#else
++static void do_check_inuse_chunk(p) mchunkptr p;
++#endif
++{
++  mstate av = get_malloc_state();
++  mchunkptr next;
++  do_check_chunk(p);
++
++  if (chunk_is_mmapped(p))
++    return; /* mmapped chunks have no next/prev */
++
++  /* Check whether it claims to be in use ... */
++  assert(inuse(p));
++
++  next = next_chunk(p);
++
++  /* ... and is surrounded by OK chunks.
++    Since more things can be checked with free chunks than inuse ones,
++    if an inuse chunk borders them and debug is on, it's worth doing them.
++  */
++  if (!prev_inuse(p))  {
++    /* Note that we cannot even look at prev unless it is not inuse */
++    mchunkptr prv = prev_chunk(p);
++    assert(next_chunk(prv) == p);
++    do_check_free_chunk(prv);
++  }
++
++  if (next == av->top) {
++    assert(prev_inuse(next));
++    assert(chunksize(next) >= MINSIZE);
++  }
++  else if (!inuse(next))
++    do_check_free_chunk(next);
++}
++
++/*
++  Properties of chunks recycled from fastbins
++*/
++
++INLINE
++#if __STD_C
++static void do_check_remalloced_chunk(mchunkptr p, INTERNAL_SIZE_T s)
++#else
++static void do_check_remalloced_chunk(p, s) mchunkptr p; INTERNAL_SIZE_T s;
++#endif
++{
++  INTERNAL_SIZE_T sz = p->size & ~PREV_INUSE;
++
++  do_check_inuse_chunk(p);
++
++  /* Legal size ... */
++  assert((sz & MALLOC_ALIGN_MASK) == 0);
++  assert((unsigned long)(sz) >= MINSIZE);
++  /* ... and alignment */
++  assert(aligned_OK(chunk2mem(p)));
++  /* chunk is less than MINSIZE more than request */
++  assert((long)(sz) - (long)(s) >= 0);
++  assert((long)(sz) - (long)(s + MINSIZE) < 0);
++}
++
++/*
++  Properties of nonrecycled chunks at the point they are malloced
++*/
++
++INLINE
++#if __STD_C
++static void do_check_malloced_chunk(mchunkptr p, INTERNAL_SIZE_T s)
++#else
++static void do_check_malloced_chunk(p, s) mchunkptr p; INTERNAL_SIZE_T s;
++#endif
++{
++  /* same as recycled case ... */
++  do_check_remalloced_chunk(p, s);
++
++  /*
++    ... plus,  must obey implementation invariant that prev_inuse is
++    always true of any allocated chunk; i.e., that each allocated
++    chunk borders either a previously allocated and still in-use
++    chunk, or the base of its memory arena. This is ensured
++    by making all allocations from the the `lowest' part of any found
++    chunk.  This does not necessarily hold however for chunks
++    recycled via fastbins.
++  */
++
++  assert(prev_inuse(p));
++}
++
++
++/*
++  Properties of malloc_state.
++
++  This may be useful for debugging malloc, as well as detecting user
++  programmer errors that somehow write into malloc_state.
++
++  If you are extending or experimenting with this malloc, you can
++  probably figure out how to hack this routine to print out or
++  display chunk addresses, sizes, bins, and other instrumentation.
++*/
++
++static void do_check_malloc_state()
++{
++  mstate av = get_malloc_state();
++  int i;
++  mchunkptr p;
++  mchunkptr q;
++  mbinptr b;
++  unsigned int binbit;
++  int empty;
++  unsigned int idx;
++  INTERNAL_SIZE_T size;
++  unsigned long total = 0;
++  int max_fast_bin;
++
++  /* internal size_t must be no wider than pointer type */
++  assert(sizeof(INTERNAL_SIZE_T) <= sizeof(char*));
++
++  /* alignment is a power of 2 */
++  assert((MALLOC_ALIGNMENT & (MALLOC_ALIGNMENT-1)) == 0);
++
++  /* cannot run remaining checks until fully initialized */
++  if (av->top == 0 || av->top == initial_top(av))
++    return;
++
++  /* pagesize is a power of 2 */
++  assert((av->pagesize & (av->pagesize-1)) == 0);
++
++  /* properties of fastbins */
++
++  /* max_fast is in allowed range */
++  assert((av->max_fast & ~1) <= request2size(MAX_FAST_SIZE));
++
++  max_fast_bin = fastbin_index(av->max_fast);
++
++  for (i = 0; i < NFASTBINS; ++i) {
++    p = av->fastbins[i];
++
++    /* all bins past max_fast are empty */
++    if (i > max_fast_bin)
++      assert(p == 0);
++
++    while (p != 0) {
++      /* each chunk claims to be inuse */
++      do_check_inuse_chunk(p);
++      total += chunksize(p);
++      /* chunk belongs in this bin */
++      assert(fastbin_index(chunksize(p)) == i);
++      p = p->fd;
++    }
++  }
++
++  if (total != 0)
++    assert(have_fastchunks(av));
++  else if (!have_fastchunks(av))
++    assert(total == 0);
++
++  /* check normal bins */
++  for (i = 1; i < NBINS; ++i) {
++    b = bin_at(av,i);
++
++    /* binmap is accurate (except for bin 1 == unsorted_chunks) */
++    if (i >= 2) {
++      binbit = get_binmap(av,i);
++      empty = last(b) == b;
++      if (!binbit)
++        assert(empty);
++      else if (!empty)
++        assert(binbit);
++    }
++
++    for (p = last(b); p != b; p = p->bk) {
++      /* each chunk claims to be free */
++      do_check_free_chunk(p);
++      size = chunksize(p);
++      total += size;
++      if (i >= 2) {
++        /* chunk belongs in bin */
++        idx = bin_index(size);
++        assert(idx == i);
++        /* lists are sorted */
++        assert(p->bk == b ||
++               (unsigned long)chunksize(p->bk) >= (unsigned long)chunksize(p));
++      }
++      /* chunk is followed by a legal chain of inuse chunks */
++      for (q = next_chunk(p);
++           (q != av->top && inuse(q) &&
++             (unsigned long)(chunksize(q)) >= MINSIZE);
++           q = next_chunk(q))
++        do_check_inuse_chunk(q);
++    }
++  }
++
++  /* top chunk is OK */
++  check_chunk(av->top);
++
++  /* sanity checks for statistics */
++
++  assert(total <= (unsigned long)(av->max_total_mem));
++  assert(av->n_mmaps >= 0);
++  assert(av->n_mmaps <= av->n_mmaps_max);
++  assert(av->n_mmaps <= av->max_n_mmaps);
++
++  assert((unsigned long)(av->sbrked_mem) <=
++         (unsigned long)(av->max_sbrked_mem));
++
++  assert((unsigned long)(av->mmapped_mem) <=
++         (unsigned long)(av->max_mmapped_mem));
++
++  assert((unsigned long)(av->max_total_mem) >=
++         (unsigned long)(av->mmapped_mem) + (unsigned long)(av->sbrked_mem));
++}
++#endif
++
++
++/* ----------- Routines dealing with system allocation -------------- */
++
++/*
++  sYSTRIm is an inverse of sorts to sYSMALLOc.  It gives memory back
++  to the system (via negative arguments to sbrk) if there is unused
++  memory at the `high' end of the malloc pool. It is called
++  automatically by free() when top space exceeds the trim
++  threshold. It is also called by the public malloc_trim routine.  It
++  returns 1 if it actually released any memory, else 0.
++*/
++
++INLINE
++#if __STD_C
++static int sYSTRIm(size_t pad, mstate av)
++#else
++static int sYSTRIm(pad, av) size_t pad; mstate av;
++#endif
++{
++  long  top_size;        /* Amount of top-most memory */
++  long  extra;           /* Amount to release */
++  long  released;        /* Amount actually released */
++  char* current_brk;     /* address returned by pre-check sbrk call */
++  char* new_brk;         /* address returned by post-check sbrk call */
++  size_t pagesz;
++
++  pagesz = av->pagesize;
++  top_size = chunksize(av->top);
++  
++  /* Release in pagesize units, keeping at least one page */
++  extra = ((top_size - pad - MINSIZE + (pagesz-1)) / pagesz - 1) * pagesz;
++  
++  if (extra > 0) {
++    
++    /*
++      Only proceed if end of memory is where we last set it.
++      This avoids problems if there were foreign sbrk calls.
++    */
++    current_brk = (char*)(MORECORE(0));
++    if (current_brk == (char*)(av->top) + top_size) {
++      
++      /*
++        Attempt to release memory. We ignore MORECORE return value,
++        and instead call again to find out where new end of memory is.
++        This avoids problems if first call releases less than we asked,
++        of if failure somehow altered brk value. (We could still
++        encounter problems if it altered brk in some very bad way,
++        but the only thing we can do is adjust anyway, which will cause
++        some downstream failure.)
++      */
++      
++      MORECORE(-extra);
++      new_brk = (char*)(MORECORE(0));
++      
++      if (new_brk != (char*)MORECORE_FAILURE) {
++        released = (long)(current_brk - new_brk);
++        
++        if (released != 0) {
++          /* Success. Adjust top. */
++          av->sbrked_mem -= released;
++          set_head(av->top, (top_size - released) | PREV_INUSE);
++          check_malloc_state();
++          return 1;
++        }
++      }
++    }
++  }
++  return 0;
++}
++
++/*
++  ------------------------- malloc_consolidate -------------------------
++
++  malloc_consolidate is a specialized version of free() that tears
++  down chunks held in fastbins.  Free itself cannot be used for this
++  purpose since, among other things, it might place chunks back onto
++  fastbins.  So, instead, we need to use a minor variant of the same
++  code.
++  
++  Also, because this routine needs to be called the first time through
++  malloc anyway, it turns out to be the perfect place to trigger
++  initialization code.
++*/
++
++INLINE
++#if __STD_C
++static void malloc_consolidate(mstate av)
++#else
++static void malloc_consolidate(av) mstate av;
++#endif
++{
++  mfastbinptr*    fb;                 /* current fastbin being consolidated */
++  mfastbinptr*    maxfb;              /* last fastbin (for loop control) */
++  mchunkptr       p;                  /* current chunk being consolidated */
++  mchunkptr       nextp;              /* next chunk to consolidate */
++  mchunkptr       unsorted_bin;       /* bin header */
++  mchunkptr       first_unsorted;     /* chunk to link to */
++
++  /* These have same use as in free() */
++  mchunkptr       nextchunk;
++  INTERNAL_SIZE_T size;
++  INTERNAL_SIZE_T nextsize;
++  INTERNAL_SIZE_T prevsize;
++  int             nextinuse;
++  mchunkptr       bck;
++  mchunkptr       fwd;
++
++  /*
++    If max_fast is 0, we know that av hasn't
++    yet been initialized, in which case do so below
++  */
++
++  if (av->max_fast != 0) {
++    clear_fastchunks(av);
++
++    unsorted_bin = unsorted_chunks(av);
++
++    /*
++      Remove each chunk from fast bin and consolidate it, placing it
++      then in unsorted bin. Among other reasons for doing this,
++      placing in unsorted bin avoids needing to calculate actual bins
++      until malloc is sure that chunks aren't immediately going to be
++      reused anyway.
++    */
++    
++    maxfb = &(av->fastbins[fastbin_index(av->max_fast)]);
++    fb = &(av->fastbins[0]);
++    do {
++      if ( (p = *fb) != 0) {
++        *fb = 0;
++        
++        do {
++          check_inuse_chunk(p);
++          nextp = p->fd;
++          
++          /* Slightly streamlined version of consolidation code in free() */
++          size = p->size & ~PREV_INUSE;
++          nextchunk = chunk_at_offset(p, size);
++          nextsize = chunksize(nextchunk);
++          
++          if (!prev_inuse(p)) {
++            prevsize = p->prev_size;
++            size += prevsize;
++            p = chunk_at_offset(p, -((long) prevsize));
++            unlink(p, bck, fwd);
++          }
++          
++          if (nextchunk != av->top) {
++            nextinuse = inuse_bit_at_offset(nextchunk, nextsize);
++            set_head(nextchunk, nextsize);
++            
++            if (!nextinuse) {
++              size += nextsize;
++              unlink(nextchunk, bck, fwd);
++            }
++            
++            first_unsorted = unsorted_bin->fd;
++            unsorted_bin->fd = p;
++            first_unsorted->bk = p;
++            
++            set_head(p, size | PREV_INUSE);
++            p->bk = unsorted_bin;
++            p->fd = first_unsorted;
++            set_foot(p, size);
++          }
++          
++          else {
++            size += nextsize;
++            set_head(p, size | PREV_INUSE);
++            av->top = p;
++          }
++          
++        } while ( (p = nextp) != 0);
++        
++      }
++    } while (fb++ != maxfb);
++  }
++  else {
++    malloc_init_state(av);
++    check_malloc_state();
++  }
++}
++
++/*
++  ------------------------------ free ------------------------------
++*/
++
++INLINE
++#if __STD_C
++void fREe(Void_t* mem)
++#else
++void fREe(mem) Void_t* mem;
++#endif
++{
++  mstate av = get_malloc_state();
++
++  mchunkptr       p;           /* chunk corresponding to mem */
++  INTERNAL_SIZE_T size;        /* its size */
++  mfastbinptr*    fb;          /* associated fastbin */
++  mchunkptr       nextchunk;   /* next contiguous chunk */
++  INTERNAL_SIZE_T nextsize;    /* its size */
++  int             nextinuse;   /* true if nextchunk is used */
++  INTERNAL_SIZE_T prevsize;    /* size of previous contiguous chunk */
++  mchunkptr       bck;         /* misc temp for linking */
++  mchunkptr       fwd;         /* misc temp for linking */
++
++
++  /* free(0) has no effect */
++  if (mem != 0) {
++    p = mem2chunk(mem);
++    size = chunksize(p);
++
++    check_inuse_chunk(p);
++
++    /*
++      If eligible, place chunk on a fastbin so it can be found
++      and used quickly in malloc.
++    */
++
++    if ((unsigned long)(size) <= (unsigned long)(av->max_fast)
++
++#if TRIM_FASTBINS
++        /* 
++           If TRIM_FASTBINS set, don't place chunks
++           bordering top into fastbins
++        */
++        && (chunk_at_offset(p, size) != av->top)
++#endif
++        ) {
++
++      set_fastchunks(av);
++      fb = &(av->fastbins[fastbin_index(size)]);
++      p->fd = *fb;
++      *fb = p;
++    }
++
++    /*
++       Consolidate other non-mmapped chunks as they arrive.
++    */
++
++    else if (!chunk_is_mmapped(p)) {
++      nextchunk = chunk_at_offset(p, size);
++      nextsize = chunksize(nextchunk);
++
++      /* consolidate backward */
++      if (!prev_inuse(p)) {
++        prevsize = p->prev_size;
++        size += prevsize;
++        p = chunk_at_offset(p, -((long) prevsize));
++        unlink(p, bck, fwd);
++      }
++
++      if (nextchunk != av->top) {
++        /* get and clear inuse bit */
++        nextinuse = inuse_bit_at_offset(nextchunk, nextsize);
++        set_head(nextchunk, nextsize);
++
++        /* consolidate forward */
++        if (!nextinuse) {
++          unlink(nextchunk, bck, fwd);
++          size += nextsize;
++        }
++
++        /*
++          Place the chunk in unsorted chunk list. Chunks are
++          not placed into regular bins until after they have
++          been given one chance to be used in malloc.
++        */
++
++        bck = unsorted_chunks(av);
++        fwd = bck->fd;
++        p->bk = bck;
++        p->fd = fwd;
++        bck->fd = p;
++        fwd->bk = p;
++
++        set_head(p, size | PREV_INUSE);
++        set_foot(p, size);
++        
++        check_free_chunk(p);
++      }
++
++      /*
++         If the chunk borders the current high end of memory,
++         consolidate into top
++      */
++
++      else {
++        size += nextsize;
++        set_head(p, size | PREV_INUSE);
++        av->top = p;
++        check_chunk(p);
++      }
++
++      /*
++        If freeing a large space, consolidate possibly-surrounding
++        chunks. Then, if the total unused topmost memory exceeds trim
++        threshold, ask malloc_trim to reduce top.
++
++        Unless max_fast is 0, we don't know if there are fastbins
++        bordering top, so we cannot tell for sure whether threshold
++        has been reached unless fastbins are consolidated.  But we
++        don't want to consolidate on each free.  As a compromise,
++        consolidation is performed if FASTBIN_CONSOLIDATION_THRESHOLD
++        is reached.
++      */
++
++      if ((unsigned long)(size) >= FASTBIN_CONSOLIDATION_THRESHOLD) { 
++        if (have_fastchunks(av)) 
++          malloc_consolidate(av);
++
++#ifndef MORECORE_CANNOT_TRIM        
++        if ((unsigned long)(chunksize(av->top)) >= 
++            (unsigned long)(av->trim_threshold)) 
++          sYSTRIm(av->top_pad, av);
++#endif
++      }
++
++    }
++    /*
++      If the chunk was allocated via mmap, release via munmap()
++      Note that if HAVE_MMAP is false but chunk_is_mmapped is
++      true, then user must have overwritten memory. There's nothing
++      we can do to catch this error unless DEBUG is set, in which case
++      check_inuse_chunk (above) will have triggered error.
++    */
++
++    else {
++#if HAVE_MMAP
++      int ret;
++      INTERNAL_SIZE_T offset = p->prev_size;
++      av->n_mmaps--;
++      av->mmapped_mem -= (size + offset);
++      ret = munmap((char*)p - offset, size + offset);
++      /* munmap returns non-zero on failure */
++      assert(ret == 0);
++#endif
++    }
++  }
++}
++
++/*
++  sysmalloc handles malloc cases requiring more memory from the system.
++  On entry, it is assumed that av->top does not have enough
++  space to service request for nb bytes, thus requiring that av->top
++  be extended or replaced.
++*/
++
++INLINE
++#if __STD_C
++static Void_t* sYSMALLOc(INTERNAL_SIZE_T nb, mstate av)
++#else
++static Void_t* sYSMALLOc(nb, av) INTERNAL_SIZE_T nb; mstate av;
++#endif
++{
++  mchunkptr       old_top;        /* incoming value of av->top */
++  INTERNAL_SIZE_T old_size;       /* its size */
++  char*           old_end;        /* its end address */
++
++  long            size;           /* arg to first MORECORE or mmap call */
++  char*           brk;            /* return value from MORECORE */
++
++  long            correction;     /* arg to 2nd MORECORE call */
++  char*           snd_brk;        /* 2nd return val */
++
++  INTERNAL_SIZE_T front_misalign; /* unusable bytes at front of new space */
++  INTERNAL_SIZE_T end_misalign;   /* partial page left at end of new space */
++  char*           aligned_brk;    /* aligned offset into brk */
++
++  mchunkptr       p;              /* the allocated/returned chunk */
++  mchunkptr       remainder;      /* remainder from allocation */
++  unsigned long   remainder_size; /* its size */
++
++  unsigned long   sum;            /* for updating stats */
++
++  size_t          pagemask  = av->pagesize - 1;
++
++
++#if HAVE_MMAP
++
++  /*
++    If have mmap, and the request size meets the mmap threshold, and
++    the system supports mmap, and there are few enough currently
++    allocated mmapped regions, try to directly map this request
++    rather than expanding top.
++  */
++
++  if ((unsigned long)(nb) >= (unsigned long)(av->mmap_threshold) &&
++      (av->n_mmaps < av->n_mmaps_max)) {
++
++    char* mm;             /* return value from mmap call*/
++
++    /*
++      Round up size to nearest page.  For mmapped chunks, the overhead
++      is one SIZE_SZ unit larger than for normal chunks, because there
++      is no following chunk whose prev_size field could be used.
++    */
++    size = (nb + SIZE_SZ + MALLOC_ALIGN_MASK + pagemask) & ~pagemask;
++
++    /* Don't try if size wraps around 0 */
++    if ((unsigned long)(size) > (unsigned long)(nb)) {
++
++      mm = (char*)(MMAP(0, size, PROT_READ|PROT_WRITE, MAP_PRIVATE));
++
++      if (mm != (char*)(MORECORE_FAILURE)) {
++
++        /*
++          The offset to the start of the mmapped region is stored
++          in the prev_size field of the chunk. This allows us to adjust
++          returned start address to meet alignment requirements here
++          and in memalign(), and still be able to compute proper
++          address argument for later munmap in free() and realloc().
++        */
++
++        front_misalign = (INTERNAL_SIZE_T)chunk2mem(mm) & MALLOC_ALIGN_MASK;
++        if (front_misalign > 0) {
++          correction = MALLOC_ALIGNMENT - front_misalign;
++          p = (mchunkptr)(mm + correction);
++          p->prev_size = correction;
++          set_head(p, (size - correction) |IS_MMAPPED);
++        }
++        else {
++          p = (mchunkptr)mm;
++          p->prev_size = 0;
++          set_head(p, size|IS_MMAPPED);
++        }
++
++        /* update statistics */
++
++        if (++av->n_mmaps > av->max_n_mmaps)
++          av->max_n_mmaps = av->n_mmaps;
++
++        sum = av->mmapped_mem += size;
++        if (sum > (unsigned long)(av->max_mmapped_mem))
++          av->max_mmapped_mem = sum;
++        sum += av->sbrked_mem;
++        if (sum > (unsigned long)(av->max_total_mem))
++          av->max_total_mem = sum;
++
++        check_chunk(p);
++
++        return chunk2mem(p);
++      }
++    }
++  }
++#endif
++
++  /* Record incoming configuration of top */
++
++  old_top  = av->top;
++  old_size = chunksize(old_top);
++  old_end  = (char*)(chunk_at_offset(old_top, old_size));
++
++  brk = snd_brk = (char*)(MORECORE_FAILURE);
++
++  /*
++     If not the first time through, we require old_size to be
++     at least MINSIZE and to have prev_inuse set.
++  */
++
++  assert((old_top == initial_top(av) && old_size == 0) ||
++         ((unsigned long) (old_size) >= MINSIZE &&
++          prev_inuse(old_top)));
++
++  /* Precondition: not enough current space to satisfy nb request */
++  assert((unsigned long)(old_size) < (unsigned long)(nb + MINSIZE));
++
++  /* Precondition: all fastbins are consolidated */
++  assert(!have_fastchunks(av));
++
++
++  /* Request enough space for nb + pad + overhead */
++
++  size = nb + av->top_pad + MINSIZE;
++
++  /*
++    If contiguous, we can subtract out existing space that we hope to
++    combine with new space. We add it back later only if
++    we don't actually get contiguous space.
++  */
++
++  if (contiguous(av))
++    size -= old_size;
++
++  /*
++    Round to a multiple of page size.
++    If MORECORE is not contiguous, this ensures that we only call it
++    with whole-page arguments.  And if MORECORE is contiguous and
++    this is not first time through, this preserves page-alignment of
++    previous calls. Otherwise, we correct to page-align below.
++  */
++
++  size = (size + pagemask) & ~pagemask;
++
++  /*
++    Don't try to call MORECORE if argument is so big as to appear
++    negative. Note that since mmap takes size_t arg, it may succeed
++    below even if we cannot call MORECORE.
++  */
++
++  if (size > 0)
++    brk = (char*)(MORECORE(size));
++
++  /*
++    If have mmap, try using it as a backup when MORECORE fails or
++    cannot be used. This is worth doing on systems that have "holes" in
++    address space, so sbrk cannot extend to give contiguous space, but
++    space is available elsewhere.  Note that we ignore mmap max count
++    and threshold limits, since the space will not be used as a
++    segregated mmap region.
++  */
++
++#if HAVE_MMAP
++  if (brk == (char*)(MORECORE_FAILURE)) {
++
++    /* Cannot merge with old top, so add its size back in */
++    if (contiguous(av))
++      size = (size + old_size + pagemask) & ~pagemask;
++
++    /* If we are relying on mmap as backup, then use larger units */
++    if ((unsigned long)(size) < (unsigned long)(MMAP_AS_MORECORE_SIZE))
++      size = MMAP_AS_MORECORE_SIZE;
++
++    /* Don't try if size wraps around 0 */
++    if ((unsigned long)(size) > (unsigned long)(nb)) {
++
++      brk = (char*)(MMAP(0, size, PROT_READ|PROT_WRITE, MAP_PRIVATE));
++
++      if (brk != (char*)(MORECORE_FAILURE)) {
++
++        /* We do not need, and cannot use, another sbrk call to find end */
++        snd_brk = brk + size;
++
++        /*
++           Record that we no longer have a contiguous sbrk region.
++           After the first time mmap is used as backup, we do not
++           ever rely on contiguous space since this could incorrectly
++           bridge regions.
++        */
++        set_noncontiguous(av);
++      }
++    }
++  }
++#endif
++
++  if (brk != (char*)(MORECORE_FAILURE)) {
++    av->sbrked_mem += size;
++
++    /*
++      If MORECORE extends previous space, we can likewise extend top size.
++    */
++
++    if (brk == old_end && snd_brk == (char*)(MORECORE_FAILURE)) {
++      set_head(old_top, (size + old_size) | PREV_INUSE);
++    }
++
++    /*
++      Otherwise, make adjustments:
++
++      * If the first time through or noncontiguous, we need to call sbrk
++        just to find out where the end of memory lies.
++
++      * We need to ensure that all returned chunks from malloc will meet
++        MALLOC_ALIGNMENT
++
++      * If there was an intervening foreign sbrk, we need to adjust sbrk
++        request size to account for fact that we will not be able to
++        combine new space with existing space in old_top.
++
++      * Almost all systems internally allocate whole pages at a time, in
++        which case we might as well use the whole last page of request.
++        So we allocate enough more memory to hit a page boundary now,
++        which in turn causes future contiguous calls to page-align.
++    */
++
++    else {
++      front_misalign = 0;
++      end_misalign = 0;
++      correction = 0;
++      aligned_brk = brk;
++
++      /* handle contiguous cases */
++      if (contiguous(av)) {
++
++        /* Guarantee alignment of first new chunk made from this space */
++
++        front_misalign = (INTERNAL_SIZE_T)chunk2mem(brk) & MALLOC_ALIGN_MASK;
++        if (front_misalign > 0) {
++
++          /*
++            Skip over some bytes to arrive at an aligned position.
++            We don't need to specially mark these wasted front bytes.
++            They will never be accessed anyway because
++            prev_inuse of av->top (and any chunk created from its start)
++            is always true after initialization.
++          */
++
++          correction = MALLOC_ALIGNMENT - front_misalign;
++          aligned_brk += correction;
++        }
++
++        /*
++          If this isn't adjacent to existing space, then we will not
++          be able to merge with old_top space, so must add to 2nd request.
++        */
++
++        correction += old_size;
++
++        /* Extend the end address to hit a page boundary */
++        end_misalign = (INTERNAL_SIZE_T)(brk + size + correction);
++        correction += ((end_misalign + pagemask) & ~pagemask) - end_misalign;
++
++        assert(correction >= 0);
++        snd_brk = (char*)(MORECORE(correction));
++
++        /*
++          If can't allocate correction, try to at least find out current
++          brk.  It might be enough to proceed without failing.
++ 
++          Note that if second sbrk did NOT fail, we assume that space
++          is contiguous with first sbrk. This is a safe assumption unless
++          program is multithreaded but doesn't use locks and a foreign sbrk
++          occurred between our first and second calls.
++        */
++
++        if (snd_brk == (char*)(MORECORE_FAILURE)) {
++          correction = 0;
++          snd_brk = (char*)(MORECORE(0));
++        }
++      }
++
++      /* handle non-contiguous cases */
++      else {
++        /* MORECORE/mmap must correctly align */
++        assert(((unsigned long)chunk2mem(brk) & MALLOC_ALIGN_MASK) == 0);
++
++        /* Find out current end of memory */
++        if (snd_brk == (char*)(MORECORE_FAILURE)) {
++          snd_brk = (char*)(MORECORE(0));
++        }
++      }
++
++      /* Adjust top based on results of second sbrk */
++      if (snd_brk != (char*)(MORECORE_FAILURE)) {
++        av->top = (mchunkptr)aligned_brk;
++        set_head(av->top, (snd_brk - aligned_brk + correction) | PREV_INUSE);
++        av->sbrked_mem += correction;
++
++        /*
++          If not the first time through, we either have a
++          gap due to foreign sbrk or a non-contiguous region.  Insert a
++          double fencepost at old_top to prevent consolidation with space
++          we don't own. These fenceposts are artificial chunks that are
++          marked as inuse and are in any case too small to use.  We need
++          two to make sizes and alignments work out.
++        */
++
++        if (old_size != 0) {
++          /*
++             Shrink old_top to insert fenceposts, keeping size a
++             multiple of MALLOC_ALIGNMENT. We know there is at least
++             enough space in old_top to do this.
++          */
++          old_size = (old_size - 3*SIZE_SZ) & ~MALLOC_ALIGN_MASK;
++          set_head(old_top, old_size | PREV_INUSE);
++
++          /*
++            Note that the following assignments completely overwrite
++            old_top when old_size was previously MINSIZE.  This is
++            intentional. We need the fencepost, even if old_top otherwise gets
++            lost.
++          */
++          chunk_at_offset(old_top, old_size          )->size =
++            SIZE_SZ|PREV_INUSE;
++
++          chunk_at_offset(old_top, old_size + SIZE_SZ)->size =
++            SIZE_SZ|PREV_INUSE;
++
++          /* If possible, release the rest. */
++          if (old_size >= MINSIZE) {
++            fREe(chunk2mem(old_top));
++          }
++
++        }
++      }
++    }
++
++    /* Update statistics */
++    sum = av->sbrked_mem;
++    if (sum > (unsigned long)(av->max_sbrked_mem))
++      av->max_sbrked_mem = sum;
++
++    sum += av->mmapped_mem;
++    if (sum > (unsigned long)(av->max_total_mem))
++      av->max_total_mem = sum;
++
++    check_malloc_state();
++
++    /* finally, do the allocation */
++    p = av->top;
++    size = chunksize(p);
++
++    /* check that one of the above allocation paths succeeded */
++    if ((unsigned long)(size) >= (unsigned long)(nb + MINSIZE)) {
++      remainder_size = size - nb;
++      remainder = chunk_at_offset(p, nb);
++      av->top = remainder;
++      set_head(p, nb | PREV_INUSE);
++      set_head(remainder, remainder_size | PREV_INUSE);
++      check_malloced_chunk(p, nb);
++      return chunk2mem(p);
++    }
++  }
++
++  /* catch all failure paths */
++  MALLOC_FAILURE_ACTION;
++  return 0;
++}
++
++
++/*
++  ------------------------------ malloc ------------------------------
++*/
++
++INLINE
++#if __STD_C
++Void_t* mALLOc(size_t bytes)
++#else
++  Void_t* mALLOc(bytes) size_t bytes;
++#endif
++{
++  mstate av = get_malloc_state();
++
++  INTERNAL_SIZE_T nb;               /* normalized request size */
++  unsigned int    idx;              /* associated bin index */
++  mbinptr         bin;              /* associated bin */
++  mfastbinptr*    fb;               /* associated fastbin */
++
++  mchunkptr       victim;           /* inspected/selected chunk */
++  INTERNAL_SIZE_T size;             /* its size */
++  int             victim_index;     /* its bin index */
++
++  mchunkptr       remainder;        /* remainder from a split */
++  unsigned long   remainder_size;   /* its size */
++
++  unsigned int    block;            /* bit map traverser */
++  unsigned int    bit;              /* bit map traverser */
++  unsigned int    map;              /* current word of binmap */
++
++  mchunkptr       fwd;              /* misc temp for linking */
++  mchunkptr       bck;              /* misc temp for linking */
++
++  /*
++    Convert request size to internal form by adding SIZE_SZ bytes
++    overhead plus possibly more to obtain necessary alignment and/or
++    to obtain a size of at least MINSIZE, the smallest allocatable
++    size. Also, checked_request2size traps (returning 0) request sizes
++    that are so large that they wrap around zero when padded and
++    aligned.
++  */
++
++  checked_request2size(bytes, nb);
++
++  /*
++    If the size qualifies as a fastbin, first check corresponding bin.
++    This code is safe to execute even if av is not yet initialized, so we
++    can try it without checking, which saves some time on this fast path.
++  */
++
++  if ((unsigned long)(nb) <= (unsigned long)(av->max_fast)) {
++    fb = &(av->fastbins[(fastbin_index(nb))]);
++    if ( (victim = *fb) != 0) {
++      *fb = victim->fd;
++      check_remalloced_chunk(victim, nb);
++      return chunk2mem(victim);
++    }
++  }
++
++  /*
++    If a small request, check regular bin.  Since these "smallbins"
++    hold one size each, no searching within bins is necessary.
++    (For a large request, we need to wait until unsorted chunks are
++    processed to find best fit. But for small ones, fits are exact
++    anyway, so we can check now, which is faster.)
++  */
++
++  if (in_smallbin_range(nb)) {
++    idx = smallbin_index(nb);
++    bin = bin_at(av,idx);
++
++    if ( (victim = last(bin)) != bin) {
++      if (victim == 0) /* initialization check */
++        malloc_consolidate(av);
++      else {
++        bck = victim->bk;
++        set_inuse_bit_at_offset(victim, nb);
++        bin->bk = bck;
++        bck->fd = bin;
++
++        check_malloced_chunk(victim, nb);
++        return chunk2mem(victim);
++      }
++    }
++  }
++
++  /*
++     If this is a large request, consolidate fastbins before continuing.
++     While it might look excessive to kill all fastbins before
++     even seeing if there is space available, this avoids
++     fragmentation problems normally associated with fastbins.
++     Also, in practice, programs tend to have runs of either small or
++     large requests, but less often mixtures, so consolidation is not
++     invoked all that often in most programs. And the programs that
++     it is called frequently in otherwise tend to fragment.
++  */
++
++  else {
++    idx = largebin_index(nb);
++    if (have_fastchunks(av))
++      malloc_consolidate(av);
++  }
++
++  /*
++    Process recently freed or remaindered chunks, taking one only if
++    it is exact fit, or, if this a small request, the chunk is remainder from
++    the most recent non-exact fit.  Place other traversed chunks in
++    bins.  Note that this step is the only place in any routine where
++    chunks are placed in bins.
++
++    The outer loop here is needed because we might not realize until
++    near the end of malloc that we should have consolidated, so must
++    do so and retry. This happens at most once, and only when we would
++    otherwise need to expand memory to service a "small" request.
++  */
++
++  for(;;) {
++
++    while ( (victim = unsorted_chunks(av)->bk) != unsorted_chunks(av)) {
++      bck = victim->bk;
++      size = chunksize(victim);
++
++      /*
++         If a small request, try to use last remainder if it is the
++         only chunk in unsorted bin.  This helps promote locality for
++         runs of consecutive small requests. This is the only
++         exception to best-fit, and applies only when there is
++         no exact fit for a small chunk.
++      */
++
++      if (in_smallbin_range(nb) &&
++          bck == unsorted_chunks(av) &&
++          victim == av->last_remainder &&
++          (unsigned long)(size) > (unsigned long)(nb + MINSIZE)) {
++
++        /* split and reattach remainder */
++        remainder_size = size - nb;
++        remainder = chunk_at_offset(victim, nb);
++        unsorted_chunks(av)->bk = unsorted_chunks(av)->fd = remainder;
++        av->last_remainder = remainder;
++        remainder->bk = remainder->fd = unsorted_chunks(av);
++
++        set_head(victim, nb | PREV_INUSE);
++        set_head(remainder, remainder_size | PREV_INUSE);
++        set_foot(remainder, remainder_size);
++
++        check_malloced_chunk(victim, nb);
++        return chunk2mem(victim);
++      }
++
++      /* remove from unsorted list */
++      unsorted_chunks(av)->bk = bck;
++      bck->fd = unsorted_chunks(av);
++
++      /* Take now instead of binning if exact fit */
++
++      if (size == nb) {
++        set_inuse_bit_at_offset(victim, size);
++        check_malloced_chunk(victim, nb);
++        return chunk2mem(victim);
++      }
++
++      /* place chunk in bin */
++
++      if (in_smallbin_range(size)) {
++        victim_index = smallbin_index(size);
++        bck = bin_at(av, victim_index);
++        fwd = bck->fd;
++      }
++      else {
++        victim_index = largebin_index(size);
++        bck = bin_at(av, victim_index);
++        fwd = bck->fd;
++
++        /* maintain large bins in sorted order */
++        if (fwd != bck) {
++          size |= PREV_INUSE; /* Or with inuse bit to speed comparisons */
++          /* if smaller than smallest, bypass loop below */
++          if ((unsigned long)(size) <= (unsigned long)(bck->bk->size)) {
++            fwd = bck;
++            bck = bck->bk;
++          }
++          else {
++            while ((unsigned long)(size) < (unsigned long)(fwd->size))
++              fwd = fwd->fd;
++            bck = fwd->bk;
++          }
++        }
++      }
++
++      mark_bin(av, victim_index);
++      victim->bk = bck;
++      victim->fd = fwd;
++      fwd->bk = victim;
++      bck->fd = victim;
++    }
++
++    /*
++      If a large request, scan through the chunks of current bin in
++      sorted order to find smallest that fits.  This is the only step
++      where an unbounded number of chunks might be scanned without doing
++      anything useful with them. However the lists tend to be short.
++    */
++
++    if (!in_smallbin_range(nb)) {
++      bin = bin_at(av, idx);
++
++      /* skip scan if empty or largest chunk is too small */
++      if ((victim = last(bin)) != bin &&
++          (unsigned long)(first(bin)->size) >= (unsigned long)(nb)) {
++
++        while (((unsigned long)(size = chunksize(victim)) <
++                (unsigned long)(nb)))
++          victim = victim->bk;
++
++        remainder_size = size - nb;
++        unlink(victim, bck, fwd);
++
++        /* Exhaust */
++        if (remainder_size < MINSIZE)  {
++          set_inuse_bit_at_offset(victim, size);
++          check_malloced_chunk(victim, nb);
++          return chunk2mem(victim);
++        }
++        /* Split */
++        else {
++          remainder = chunk_at_offset(victim, nb);
++          unsorted_chunks(av)->bk = unsorted_chunks(av)->fd = remainder;
++          remainder->bk = remainder->fd = unsorted_chunks(av);
++          set_head(victim, nb | PREV_INUSE);
++          set_head(remainder, remainder_size | PREV_INUSE);
++          set_foot(remainder, remainder_size);
++          check_malloced_chunk(victim, nb);
++          return chunk2mem(victim);
++        }
++      }
++    }
++
++    /*
++      Search for a chunk by scanning bins, starting with next largest
++      bin. This search is strictly by best-fit; i.e., the smallest
++      (with ties going to approximately the least recently used) chunk
++      that fits is selected.
++
++      The bitmap avoids needing to check that most blocks are nonempty.
++      The particular case of skipping all bins during warm-up phases
++      when no chunks have been returned yet is faster than it might look.
++    */
++
++    ++idx;
++    bin = bin_at(av,idx);
++    block = idx2block(idx);
++    map = av->binmap[block];
++    bit = idx2bit(idx);
++
++    for (;;) {
++
++      /* Skip rest of block if there are no more set bits in this block.  */
++      if (bit > map || bit == 0) {
++        do {
++          if (++block >= BINMAPSIZE)  /* out of bins */
++            goto use_top;
++        } while ( (map = av->binmap[block]) == 0);
++
++        bin = bin_at(av, (block << BINMAPSHIFT));
++        bit = 1;
++      }
++
++      /* Advance to bin with set bit. There must be one. */
++      while ((bit & map) == 0) {
++        bin = next_bin(bin);
++        bit <<= 1;
++        assert(bit != 0);
++      }
++
++      /* Inspect the bin. It is likely to be non-empty */
++      victim = last(bin);
++
++      /*  If a false alarm (empty bin), clear the bit. */
++      if (victim == bin) {
++        av->binmap[block] = map &= ~bit; /* Write through */
++        bin = next_bin(bin);
++        bit <<= 1;
++      }
++
++      else {
++        size = chunksize(victim);
++
++        /*  We know the first chunk in this bin is big enough to use. */
++        assert((unsigned long)(size) >= (unsigned long)(nb));
++
++        remainder_size = size - nb;
++
++        /* unlink */
++        bck = victim->bk;
++        bin->bk = bck;
++        bck->fd = bin;
++
++        /* Exhaust */
++        if (remainder_size < MINSIZE) {
++          set_inuse_bit_at_offset(victim, size);
++          check_malloced_chunk(victim, nb);
++          return chunk2mem(victim);
++        }
++
++        /* Split */
++        else {
++          remainder = chunk_at_offset(victim, nb);
++
++          unsorted_chunks(av)->bk = unsorted_chunks(av)->fd = remainder;
++          remainder->bk = remainder->fd = unsorted_chunks(av);
++          /* advertise as last remainder */
++          if (in_smallbin_range(nb))
++            av->last_remainder = remainder;
++
++          set_head(victim, nb | PREV_INUSE);
++          set_head(remainder, remainder_size | PREV_INUSE);
++          set_foot(remainder, remainder_size);
++          check_malloced_chunk(victim, nb);
++          return chunk2mem(victim);
++        }
++      }
++    }
++
++  use_top:
++    /*
++      If large enough, split off the chunk bordering the end of memory
++      (held in av->top). Note that this is in accord with the best-fit
++      search rule.  In effect, av->top is treated as larger (and thus
++      less well fitting) than any other available chunk since it can
++      be extended to be as large as necessary (up to system
++      limitations).
++
++      We require that av->top always exists (i.e., has size >=
++      MINSIZE) after initialization, so if it would otherwise be
++      exhuasted by current request, it is replenished. (The main
++      reason for ensuring it exists is that we may need MINSIZE space
++      to put in fenceposts in sysmalloc.)
++    */
++
++    victim = av->top;
++    size = chunksize(victim);
++
++    if ((unsigned long)(size) >= (unsigned long)(nb + MINSIZE)) {
++      remainder_size = size - nb;
++      remainder = chunk_at_offset(victim, nb);
++      av->top = remainder;
++      set_head(victim, nb | PREV_INUSE);
++      set_head(remainder, remainder_size | PREV_INUSE);
++
++      check_malloced_chunk(victim, nb);
++      return chunk2mem(victim);
++    }
++
++    /*
++      If there is space available in fastbins, consolidate and retry,
++      to possibly avoid expanding memory. This can occur only if nb is
++      in smallbin range so we didn't consolidate upon entry.
++    */
++
++    else if (have_fastchunks(av)) {
++      assert(in_smallbin_range(nb));
++      malloc_consolidate(av);
++      idx = smallbin_index(nb); /* restore original bin index */
++    }
++
++    /*
++       Otherwise, relay to handle system-dependent cases
++    */
++    else
++      return sYSMALLOc(nb, av);
++  }
++}
++
++/*
++  ------------------------------ realloc ------------------------------
++*/
++
++
++INLINE
++#if __STD_C
++Void_t* rEALLOc(Void_t* oldmem, size_t bytes)
++#else
++Void_t* rEALLOc(oldmem, bytes) Void_t* oldmem; size_t bytes;
++#endif
++{
++  mstate av = get_malloc_state();
++
++  INTERNAL_SIZE_T  nb;              /* padded request size */
++
++  mchunkptr        oldp;            /* chunk corresponding to oldmem */
++  INTERNAL_SIZE_T  oldsize;         /* its size */
++
++  mchunkptr        newp;            /* chunk to return */
++  INTERNAL_SIZE_T  newsize;         /* its size */
++  Void_t*          newmem;          /* corresponding user mem */
++
++  mchunkptr        next;            /* next contiguous chunk after oldp */
++
++  mchunkptr        remainder;       /* extra space at end of newp */
++  unsigned long    remainder_size;  /* its size */
++
++  mchunkptr        bck;             /* misc temp for linking */
++  mchunkptr        fwd;             /* misc temp for linking */
++
++  unsigned long    copysize;        /* bytes to copy */
++  unsigned int     ncopies;         /* INTERNAL_SIZE_T words to copy */
++  INTERNAL_SIZE_T* s;               /* copy source */
++  INTERNAL_SIZE_T* d;               /* copy destination */
++
++
++#ifdef REALLOC_ZERO_BYTES_FREES
++  if (bytes == 0) {
++    fREe(oldmem);
++    return 0;
++  }
++#endif
++
++  /* realloc of null is supposed to be same as malloc */
++  if (oldmem == 0) return mALLOc(bytes);
++
++  checked_request2size(bytes, nb);
++
++  oldp    = mem2chunk(oldmem);
++  oldsize = chunksize(oldp);
++
++  check_inuse_chunk(oldp);
++
++  if (!chunk_is_mmapped(oldp)) {
++
++    if ((unsigned long)(oldsize) >= (unsigned long)(nb)) {
++      /* already big enough; split below */
++      newp = oldp;
++      newsize = oldsize;
++    }
++
++    else {
++      next = chunk_at_offset(oldp, oldsize);
++
++      /* Try to expand forward into top */
++      if (next == av->top &&
++          (unsigned long)(newsize = oldsize + chunksize(next)) >=
++          (unsigned long)(nb + MINSIZE)) {
++        set_head_size(oldp, nb);
++        av->top = chunk_at_offset(oldp, nb);
++        set_head(av->top, (newsize - nb) | PREV_INUSE);
++        return chunk2mem(oldp);
++      }
++
++      /* Try to expand forward into next chunk;  split off remainder below */
++      else if (next != av->top &&
++               !inuse(next) &&
++               (unsigned long)(newsize = oldsize + chunksize(next)) >=
++               (unsigned long)(nb)) {
++        newp = oldp;
++        unlink(next, bck, fwd);
++      }
++
++      /* allocate, copy, free */
++      else {
++        newmem = mALLOc(nb - MALLOC_ALIGN_MASK);
++        if (newmem == 0)
++          return 0; /* propagate failure */
++
++        newp = mem2chunk(newmem);
++        newsize = chunksize(newp);
++
++        /*
++          Avoid copy if newp is next chunk after oldp.
++        */
++        if (newp == next) {
++          newsize += oldsize;
++          newp = oldp;
++        }
++        else {
++          /*
++            Unroll copy of <= 36 bytes (72 if 8byte sizes)
++            We know that contents have an odd number of
++            INTERNAL_SIZE_T-sized words; minimally 3.
++          */
++
++          copysize = oldsize - SIZE_SZ;
++          s = (INTERNAL_SIZE_T*)(oldmem);
++          d = (INTERNAL_SIZE_T*)(newmem);
++          ncopies = copysize / sizeof(INTERNAL_SIZE_T);
++          assert(ncopies >= 3);
++
++          if (ncopies > 9)
++            MALLOC_COPY(d, s, copysize);
++
++          else {
++            *(d+0) = *(s+0);
++            *(d+1) = *(s+1);
++            *(d+2) = *(s+2);
++            if (ncopies > 4) {
++              *(d+3) = *(s+3);
++              *(d+4) = *(s+4);
++              if (ncopies > 6) {
++                *(d+5) = *(s+5);
++                *(d+6) = *(s+6);
++                if (ncopies > 8) {
++                  *(d+7) = *(s+7);
++                  *(d+8) = *(s+8);
++                }
++              }
++            }
++          }
++
++          fREe(oldmem);
++          check_inuse_chunk(newp);
++          return chunk2mem(newp);
++        }
++      }
++    }
++
++    /* If possible, free extra space in old or extended chunk */
++
++    assert((unsigned long)(newsize) >= (unsigned long)(nb));
++
++    remainder_size = newsize - nb;
++
++    if (remainder_size < MINSIZE) { /* not enough extra to split off */
++      set_head_size(newp, newsize);
++      set_inuse_bit_at_offset(newp, newsize);
++    }
++    else { /* split remainder */
++      remainder = chunk_at_offset(newp, nb);
++      set_head_size(newp, nb);
++      set_head(remainder, remainder_size | PREV_INUSE);
++      /* Mark remainder as inuse so free() won't complain */
++      set_inuse_bit_at_offset(remainder, remainder_size);
++      fREe(chunk2mem(remainder));
++    }
++
++    check_inuse_chunk(newp);
++    return chunk2mem(newp);
++  }
++
++  /*
++    Handle mmap cases
++  */
++
++  else {
++#if HAVE_MMAP
++
++#if HAVE_MREMAP
++    INTERNAL_SIZE_T offset = oldp->prev_size;
++    size_t pagemask = av->pagesize - 1;
++    char *cp;
++    unsigned long sum;
++
++    /* Note the extra SIZE_SZ overhead */
++    newsize = (nb + offset + SIZE_SZ + pagemask) & ~pagemask;
++
++    /* don't need to remap if still within same page */
++    if (oldsize == newsize - offset)
++      return oldmem;
++
++    cp = (char*)mremap((char*)oldp - offset, oldsize + offset, newsize, 1);
++
++    if (cp != (char*)MORECORE_FAILURE) {
++
++      newp = (mchunkptr)(cp + offset);
++      set_head(newp, (newsize - offset)|IS_MMAPPED);
++
++      assert(aligned_OK(chunk2mem(newp)));
++      assert((newp->prev_size == offset));
++
++      /* update statistics */
++      sum = av->mmapped_mem += newsize - oldsize;
++      if (sum > (unsigned long)(av->max_mmapped_mem))
++        av->max_mmapped_mem = sum;
++      sum += av->sbrked_mem;
++      if (sum > (unsigned long)(av->max_total_mem))
++        av->max_total_mem = sum;
++
++      return chunk2mem(newp);
++    }
++#endif
++
++    /* Note the extra SIZE_SZ overhead. */
++    if ((unsigned long)(oldsize) >= (unsigned long)(nb + SIZE_SZ))
++      newmem = oldmem; /* do nothing */
++    else {
++      /* Must alloc, copy, free. */
++      newmem = mALLOc(nb - MALLOC_ALIGN_MASK);
++      if (newmem != 0) {
++        MALLOC_COPY(newmem, oldmem, oldsize - 2*SIZE_SZ);
++        fREe(oldmem);
++      }
++    }
++    return newmem;
++
++#else
++    /* If !HAVE_MMAP, but chunk_is_mmapped, user must have overwritten mem */
++    check_malloc_state();
++    MALLOC_FAILURE_ACTION;
++    return 0;
++#endif
++  }
++}
++
++/*
++  ------------------------------ memalign ------------------------------
++*/
++
++INLINE
++#if __STD_C
++Void_t* mEMALIGn(size_t alignment, size_t bytes)
++#else
++Void_t* mEMALIGn(alignment, bytes) size_t alignment; size_t bytes;
++#endif
++{
++  INTERNAL_SIZE_T nb;             /* padded  request size */
++  char*           m;              /* memory returned by malloc call */
++  mchunkptr       p;              /* corresponding chunk */
++  char*           brk;            /* alignment point within p */
++  mchunkptr       newp;           /* chunk to return */
++  INTERNAL_SIZE_T newsize;        /* its size */
++  INTERNAL_SIZE_T leadsize;       /* leading space before alignment point */
++  mchunkptr       remainder;      /* spare room at end to split off */
++  unsigned long   remainder_size; /* its size */
++  INTERNAL_SIZE_T size;
++
++  /* If need less alignment than we give anyway, just relay to malloc */
++
++  if (alignment <= MALLOC_ALIGNMENT) return mALLOc(bytes);
++
++  /* Otherwise, ensure that it is at least a minimum chunk size */
++
++  if (alignment <  MINSIZE) alignment = MINSIZE;
++
++  /* Make sure alignment is power of 2 (in case MINSIZE is not).  */
++  if ((alignment & (alignment - 1)) != 0) {
++    size_t a = MALLOC_ALIGNMENT * 2;
++    while ((unsigned long)a < (unsigned long)alignment) a <<= 1;
++    alignment = a;
++  }
++
++  checked_request2size(bytes, nb);
++
++  /*
++    Strategy: find a spot within that chunk that meets the alignment
++    request, and then possibly free the leading and trailing space.
++  */
++
++
++  /* Call malloc with worst case padding to hit alignment. */
++
++  m  = (char*)(mALLOc(nb + alignment + MINSIZE));
++
++  if (m == 0) return 0; /* propagate failure */
++
++  p = mem2chunk(m);
++
++  if ((((unsigned long)(m)) % alignment) != 0) { /* misaligned */
++
++    /*
++      Find an aligned spot inside chunk.  Since we need to give back
++      leading space in a chunk of at least MINSIZE, if the first
++      calculation places us at a spot with less than MINSIZE leader,
++      we can move to the next aligned spot -- we've allocated enough
++      total room so that this is always possible.
++    */
++
++    brk = (char*)mem2chunk(((unsigned long)(m + alignment - 1)) &
++                           -((signed long) alignment));
++    if ((unsigned long)(brk - (char*)(p)) < MINSIZE)
++      brk += alignment;
++
++    newp = (mchunkptr)brk;
++    leadsize = brk - (char*)(p);
++    newsize = chunksize(p) - leadsize;
++
++    /* For mmapped chunks, just adjust offset */
++    if (chunk_is_mmapped(p)) {
++      newp->prev_size = p->prev_size + leadsize;
++      set_head(newp, newsize|IS_MMAPPED);
++      return chunk2mem(newp);
++    }
++
++    /* Otherwise, give back leader, use the rest */
++    set_head(newp, newsize | PREV_INUSE);
++    set_inuse_bit_at_offset(newp, newsize);
++    set_head_size(p, leadsize);
++    fREe(chunk2mem(p));
++    p = newp;
++
++    assert (newsize >= nb &&
++            (((unsigned long)(chunk2mem(p))) % alignment) == 0);
++  }
++
++  /* Also give back spare room at the end */
++  if (!chunk_is_mmapped(p)) {
++    size = chunksize(p);
++    if ((unsigned long)(size) > (unsigned long)(nb + MINSIZE)) {
++      remainder_size = size - nb;
++      remainder = chunk_at_offset(p, nb);
++      set_head(remainder, remainder_size | PREV_INUSE);
++      set_head_size(p, nb);
++      fREe(chunk2mem(remainder));
++    }
++  }
++
++  check_inuse_chunk(p);
++  return chunk2mem(p);
++}
++
++/*
++  ------------------------------ calloc ------------------------------
++*/
++
++INLINE
++#if __STD_C
++Void_t* cALLOc(size_t n_elements, size_t elem_size)
++#else
++Void_t* cALLOc(n_elements, elem_size) size_t n_elements; size_t elem_size;
++#endif
++{
++  mchunkptr p;
++  unsigned long clearsize;
++  unsigned long nclears;
++  INTERNAL_SIZE_T* d;
++
++  Void_t* mem = mALLOc(n_elements * elem_size);
++
++  if (mem != 0) {
++    p = mem2chunk(mem);
++
++    if (!chunk_is_mmapped(p))
++    {
++      /*
++        Unroll clear of <= 36 bytes (72 if 8byte sizes)
++        We know that contents have an odd number of
++        INTERNAL_SIZE_T-sized words; minimally 3.
++      */
++
++      d = (INTERNAL_SIZE_T*)mem;
++      clearsize = chunksize(p) - SIZE_SZ;
++      nclears = clearsize / sizeof(INTERNAL_SIZE_T);
++      assert(nclears >= 3);
++
++      if (nclears > 9)
++        MALLOC_ZERO(d, clearsize);
++
++      else {
++        *(d+0) = 0;
++        *(d+1) = 0;
++        *(d+2) = 0;
++        if (nclears > 4) {
++          *(d+3) = 0;
++          *(d+4) = 0;
++          if (nclears > 6) {
++            *(d+5) = 0;
++            *(d+6) = 0;
++            if (nclears > 8) {
++              *(d+7) = 0;
++              *(d+8) = 0;
++            }
++          }
++        }
++      }
++    }
++#if ! MMAP_CLEARS
++    else
++    {
++      d = (INTERNAL_SIZE_T*)mem;
++      clearsize = chunksize(p) - 2 * SIZE_SZ;
++      MALLOC_ZERO(d, clearsize);
++    }
++#endif
++  }
++  return mem;
++}
++
++/*
++  ------------------------------ cfree ------------------------------
++*/
++
++INLINE
++#if __STD_C
++void cFREe(Void_t *mem)
++#else
++void cFREe(mem) Void_t *mem;
++#endif
++{
++  fREe(mem);
++}
++
++/*
++  ------------------------------ ialloc ------------------------------
++  ialloc provides common support for independent_X routines, handling all of
++  the combinations that can result.
++
++  The opts arg has:
++    bit 0 set if all elements are same size (using sizes[0])
++    bit 1 set if elements should be zeroed
++*/
++
++
++INLINE
++#if __STD_C
++static Void_t** iALLOc(size_t n_elements,
++                       size_t* sizes,
++                       int opts,
++                       Void_t* chunks[])
++#else
++static Void_t** iALLOc(n_elements, sizes, opts, chunks) size_t n_elements; size_t* sizes; int opts; Void_t* chunks[];
++#endif
++{
++  mstate av = get_malloc_state();
++  INTERNAL_SIZE_T element_size;   /* chunksize of each element, if all same */
++  INTERNAL_SIZE_T contents_size;  /* total size of elements */
++  INTERNAL_SIZE_T array_size;     /* request size of pointer array */
++  Void_t*         mem;            /* malloced aggregate space */
++  mchunkptr       p;              /* corresponding chunk */
++  INTERNAL_SIZE_T remainder_size; /* remaining bytes while splitting */
++  Void_t**        marray;         /* either "chunks" or malloced ptr array */
++  mchunkptr       array_chunk;    /* chunk for malloced ptr array */
++  int             mmx;            /* to disable mmap */
++  INTERNAL_SIZE_T size;
++  size_t          i;
++
++  /* Ensure initialization/consolidation */
++  if (have_fastchunks(av)) malloc_consolidate(av);
++
++  /* compute array length, if needed */
++  if (chunks != 0) {
++    if (n_elements == 0)
++      return chunks; /* nothing to do */
++    marray = chunks;
++    array_size = 0;
++  }
++  else {
++    /* if empty req, must still return chunk representing empty array */
++    if (n_elements == 0)
++      return (Void_t**) mALLOc(0);
++    marray = 0;
++    array_size = request2size(n_elements * (sizeof(Void_t*)));
++  }
++
++  /* compute total element size */
++  if (opts & 0x1) { /* all-same-size */
++    element_size = request2size(*sizes);
++    contents_size = n_elements * element_size;
++  }
++  else { /* add up all the sizes */
++    element_size = 0;
++    contents_size = 0;
++    for (i = 0; i != n_elements; ++i)
++      contents_size += request2size(sizes[i]);
++  }
++
++  /* subtract out alignment bytes from total to minimize overallocation */
++  size = contents_size + array_size - MALLOC_ALIGN_MASK;
++
++  /*
++     Allocate the aggregate chunk.
++     But first disable mmap so malloc won't use it, since
++     we would not be able to later free/realloc space internal
++     to a segregated mmap region.
++ */
++  mmx = av->n_mmaps_max;   /* disable mmap */
++  av->n_mmaps_max = 0;
++  mem = mALLOc(size);
++  av->n_mmaps_max = mmx;   /* reset mmap */
++  if (mem == 0)
++    return 0;
++
++  p = mem2chunk(mem);
++  assert(!chunk_is_mmapped(p));
++  remainder_size = chunksize(p);
++
++  if (opts & 0x2) {       /* optionally clear the elements */
++    MALLOC_ZERO(mem, remainder_size - SIZE_SZ - array_size);
++  }
++
++  /* If not provided, allocate the pointer array as final part of chunk */
++  if (marray == 0) {
++    array_chunk = chunk_at_offset(p, contents_size);
++    marray = (Void_t**) (chunk2mem(array_chunk));
++    set_head(array_chunk, (remainder_size - contents_size) | PREV_INUSE);
++    remainder_size = contents_size;
++  }
++
++  /* split out elements */
++  for (i = 0; ; ++i) {
++    marray[i] = chunk2mem(p);
++    if (i != n_elements-1) {
++      if (element_size != 0)
++        size = element_size;
++      else
++        size = request2size(sizes[i]);
++      remainder_size -= size;
++      set_head(p, size | PREV_INUSE);
++      p = chunk_at_offset(p, size);
++    }
++    else { /* the final element absorbs any overallocation slop */
++      set_head(p, remainder_size | PREV_INUSE);
++      break;
++    }
++  }
++
++#ifdef DEBUG
++  if (marray != chunks) {
++    /* final element must have exactly exhausted chunk */
++    if (element_size != 0)
++      assert(remainder_size == element_size);
++    else
++      assert(remainder_size == request2size(sizes[i]));
++    check_inuse_chunk(mem2chunk(marray));
++  }
++
++  for (i = 0; i != n_elements; ++i)
++    check_inuse_chunk(mem2chunk(marray[i]));
++#endif
++
++  return marray;
++}
++
++
++/*
++  ------------------------- independent_calloc -------------------------
++*/
++
++INLINE
++#if __STD_C
++Void_t** iCALLOc(size_t n_elements, size_t elem_size, Void_t* chunks[])
++#else
++Void_t** iCALLOc(n_elements, elem_size, chunks) size_t n_elements; size_t elem_size; Void_t* chunks[];
++#endif
++{
++  size_t sz = elem_size; /* serves as 1-element array */
++  /* opts arg of 3 means all elements are same size, and should be cleared */
++  return iALLOc(n_elements, &sz, 3, chunks);
++}
++
++/*
++  ------------------------- independent_comalloc -------------------------
++*/
++
++INLINE
++#if __STD_C
++Void_t** iCOMALLOc(size_t n_elements, size_t sizes[], Void_t* chunks[])
++#else
++Void_t** iCOMALLOc(n_elements, sizes, chunks) size_t n_elements; size_t sizes[]; Void_t* chunks[];
++#endif
++{
++  return iALLOc(n_elements, sizes, 0, chunks);
++}
++
++
++/*
++  ------------------------------ valloc ------------------------------
++*/
++
++INLINE
++#if __STD_C
++Void_t* vALLOc(size_t bytes)
++#else
++Void_t* vALLOc(bytes) size_t bytes;
++#endif
++{
++  /* Ensure initialization/consolidation */
++  mstate av = get_malloc_state();
++  if (have_fastchunks(av)) malloc_consolidate(av);
++  return mEMALIGn(av->pagesize, bytes);
++}
++
++/*
++  ------------------------------ pvalloc ------------------------------
++*/
++
++
++#if __STD_C
++Void_t* pVALLOc(size_t bytes)
++#else
++Void_t* pVALLOc(bytes) size_t bytes;
++#endif
++{
++  mstate av = get_malloc_state();
++  size_t pagesz;
++
++  /* Ensure initialization/consolidation */
++  if (have_fastchunks(av)) malloc_consolidate(av);
++  pagesz = av->pagesize;
++  return mEMALIGn(pagesz, (bytes + pagesz - 1) & ~(pagesz - 1));
++}
++
++
++/*
++  ------------------------------ malloc_trim ------------------------------
++*/
++
++INLINE
++#if __STD_C
++int mTRIm(size_t pad)
++#else
++int mTRIm(pad) size_t pad;
++#endif
++{
++  mstate av = get_malloc_state();
++  /* Ensure initialization/consolidation */
++  malloc_consolidate(av);
++
++#ifndef MORECORE_CANNOT_TRIM
++  return sYSTRIm(pad, av);
++#else
++  return 0;
++#endif
++}
++
++
++/*
++  ------------------------- malloc_usable_size -------------------------
++*/
++
++INLINE
++#if __STD_C
++size_t mUSABLe(Void_t* mem)
++#else
++size_t mUSABLe(mem) Void_t* mem;
++#endif
++{
++  mchunkptr p;
++  if (mem != 0) {
++    p = mem2chunk(mem);
++    if (chunk_is_mmapped(p))
++      return chunksize(p) - 2*SIZE_SZ;
++    else if (inuse(p))
++      return chunksize(p) - SIZE_SZ;
++  }
++  return 0;
++}
++
++/*
++  ------------------------------ mallinfo ------------------------------
++*/
++
++struct mallinfo mALLINFo()
++{
++  mstate av = get_malloc_state();
++  struct mallinfo mi;
++  unsigned int i;
++  mbinptr b;
++  mchunkptr p;
++  INTERNAL_SIZE_T avail;
++  INTERNAL_SIZE_T fastavail;
++  int nblocks;
++  int nfastblocks;
++
++  /* Ensure initialization */
++  if (av->top == 0)  malloc_consolidate(av);
++
++  check_malloc_state();
++
++  /* Account for top */
++  avail = chunksize(av->top);
++  nblocks = 1;  /* top always exists */
++
++  /* traverse fastbins */
++  nfastblocks = 0;
++  fastavail = 0;
++
++  for (i = 0; i < NFASTBINS; ++i) {
++    for (p = av->fastbins[i]; p != 0; p = p->fd) {
++      ++nfastblocks;
++      fastavail += chunksize(p);
++    }
++  }
++
++  avail += fastavail;
++
++  /* traverse regular bins */
++  for (i = 1; i < NBINS; ++i) {
++    b = bin_at(av, i);
++    for (p = last(b); p != b; p = p->bk) {
++      ++nblocks;
++      avail += chunksize(p);
++    }
++  }
++
++  mi.smblks = nfastblocks;
++  mi.ordblks = nblocks;
++  mi.fordblks = avail;
++  mi.uordblks = av->sbrked_mem - avail;
++  mi.arena = av->sbrked_mem;
++  mi.hblks = av->n_mmaps;
++  mi.hblkhd = av->mmapped_mem;
++  mi.fsmblks = fastavail;
++  mi.keepcost = chunksize(av->top);
++  mi.usmblks = av->max_total_mem;
++  return mi;
++}
++
++/*
++  ------------------------------ malloc_stats ------------------------------
++*/
++
++void mSTATs()
++{
++  struct mallinfo mi = mALLINFo();
++
++#ifdef WIN32
++  {
++    unsigned long free, reserved, committed;
++    vminfo (&free, &reserved, &committed);
++    fprintf(stderr, "free bytes       = %10lu\n",
++            free);
++    fprintf(stderr, "reserved bytes   = %10lu\n",
++            reserved);
++    fprintf(stderr, "committed bytes  = %10lu\n",
++            committed);
++  }
++#endif
++
++
++  fprintf(stderr, "max system bytes = %10lu\n",
++          (unsigned long)(mi.usmblks));
++  fprintf(stderr, "system bytes     = %10lu\n",
++          (unsigned long)(mi.arena + mi.hblkhd));
++  fprintf(stderr, "in use bytes     = %10lu\n",
++          (unsigned long)(mi.uordblks + mi.hblkhd));
++
++
++#ifdef WIN32
++  {
++    unsigned long kernel, user;
++    if (cpuinfo (TRUE, &kernel, &user)) {
++      fprintf(stderr, "kernel ms        = %10lu\n",
++              kernel);
++      fprintf(stderr, "user ms          = %10lu\n",
++              user);
++    }
++  }
++#endif
++}
++
++
++/*
++  ------------------------------ mallopt ------------------------------
++*/
++
++INLINE
++#if __STD_C
++int mALLOPt(int param_number, int value)
++#else
++int mALLOPt(param_number, value) int param_number; int value;
++#endif
++{
++  mstate av = get_malloc_state();
++  /* Ensure initialization/consolidation */
++  malloc_consolidate(av);
++
++  switch(param_number) {
++  case M_MXFAST:
++    if (value >= 0 && value <= MAX_FAST_SIZE) {
++      set_max_fast(av, value);
++      return 1;
++    }
++    else
++      return 0;
++
++  case M_TRIM_THRESHOLD:
++    av->trim_threshold = value;
++    return 1;
++
++  case M_TOP_PAD:
++    av->top_pad = value;
++    return 1;
++
++  case M_MMAP_THRESHOLD:
++    av->mmap_threshold = value;
++    return 1;
++
++  case M_MMAP_MAX:
++#if !HAVE_MMAP
++    if (value != 0)
++      return 0;
++#endif
++    av->n_mmaps_max = value;
++    return 1;
++
++  default:
++    return 0;
++  }
++}
++
++
++/*
++  -------------------- Alternative MORECORE functions --------------------
++*/
++
++
++/*
++  General Requirements for MORECORE.
++
++  The MORECORE function must have the following properties:
++
++  If MORECORE_CONTIGUOUS is false:
++
++    * MORECORE must allocate in multiples of pagesize. It will
++      only be called with arguments that are multiples of pagesize.
++
++    * MORECORE(0) must return an address that is at least
++      MALLOC_ALIGNMENT aligned. (Page-aligning always suffices.)
++
++  else (i.e. If MORECORE_CONTIGUOUS is true):
++
++    * Consecutive calls to MORECORE with positive arguments
++      return increasing addresses, indicating that space has been
++      contiguously extended.
++
++    * MORECORE need not allocate in multiples of pagesize.
++      Calls to MORECORE need not have args of multiples of pagesize.
++
++    * MORECORE need not page-align.
++
++  In either case:
++
++    * MORECORE may allocate more memory than requested. (Or even less,
++      but this will generally result in a malloc failure.)
++
++    * MORECORE must not allocate memory when given argument zero, but
++      instead return one past the end address of memory from previous
++      nonzero call. This malloc does NOT call MORECORE(0)
++      until at least one call with positive arguments is made, so
++      the initial value returned is not important.
++
++    * Even though consecutive calls to MORECORE need not return contiguous
++      addresses, it must be OK for malloc'ed chunks to span multiple
++      regions in those cases where they do happen to be contiguous.
++
++    * MORECORE need not handle negative arguments -- it may instead
++      just return MORECORE_FAILURE when given negative arguments.
++      Negative arguments are always multiples of pagesize. MORECORE
++      must not misinterpret negative args as large positive unsigned
++      args. You can suppress all such calls from even occurring by defining
++      MORECORE_CANNOT_TRIM,
++
++  There is some variation across systems about the type of the
++  argument to sbrk/MORECORE. If size_t is unsigned, then it cannot
++  actually be size_t, because sbrk supports negative args, so it is
++  normally the signed type of the same width as size_t (sometimes
++  declared as "intptr_t", and sometimes "ptrdiff_t").  It doesn't much
++  matter though. Internally, we use "long" as arguments, which should
++  work across all reasonable possibilities.
++
++  Additionally, if MORECORE ever returns failure for a positive
++  request, and HAVE_MMAP is true, then mmap is used as a noncontiguous
++  system allocator. This is a useful backup strategy for systems with
++  holes in address spaces -- in this case sbrk cannot contiguously
++  expand the heap, but mmap may be able to map noncontiguous space.
++
++  If you'd like mmap to ALWAYS be used, you can define MORECORE to be
++  a function that always returns MORECORE_FAILURE.
++
++  If you are using this malloc with something other than sbrk (or its
++  emulation) to supply memory regions, you probably want to set
++  MORECORE_CONTIGUOUS as false.  As an example, here is a custom
++  allocator kindly contributed for pre-OSX macOS.  It uses virtually
++  but not necessarily physically contiguous non-paged memory (locked
++  in, present and won't get swapped out).  You can use it by
++  uncommenting this section, adding some #includes, and setting up the
++  appropriate defines above:
++
++      #define MORECORE osMoreCore
++      #define MORECORE_CONTIGUOUS 0
++
++  There is also a shutdown routine that should somehow be called for
++  cleanup upon program exit.
++
++  #define MAX_POOL_ENTRIES 100
++  #define MINIMUM_MORECORE_SIZE  (64 * 1024)
++  static int next_os_pool;
++  void *our_os_pools[MAX_POOL_ENTRIES];
++
++  void *osMoreCore(int size)
++  {
++    void *ptr = 0;
++    static void *sbrk_top = 0;
++
++    if (size > 0)
++    {
++      if (size < MINIMUM_MORECORE_SIZE)
++         size = MINIMUM_MORECORE_SIZE;
++      if (CurrentExecutionLevel() == kTaskLevel)
++         ptr = PoolAllocateResident(size + RM_PAGE_SIZE, 0);
++      if (ptr == 0)
++      {
++        return (void *) MORECORE_FAILURE;
++      }
++      // save ptrs so they can be freed during cleanup
++      our_os_pools[next_os_pool] = ptr;
++      next_os_pool++;
++      ptr = (void *) ((((unsigned long) ptr) + RM_PAGE_MASK) & ~RM_PAGE_MASK);
++      sbrk_top = (char *) ptr + size;
++      return ptr;
++    }
++    else if (size < 0)
++    {
++      // we don't currently support shrink behavior
++      return (void *) MORECORE_FAILURE;
++    }
++    else
++    {
++      return sbrk_top;
++    }
++  }
++
++  // cleanup any allocated memory pools
++  // called as last thing before shutting down driver
++
++  void osCleanupMem(void)
++  {
++    void **ptr;
++
++    for (ptr = our_os_pools; ptr < &our_os_pools[MAX_POOL_ENTRIES]; ptr++)
++      if (*ptr)
++      {
++         PoolDeallocate(*ptr);
++         *ptr = 0;
++      }
++  }
++
++*/
++
++
++/*
++  --------------------------------------------------------------
++
++  Emulation of sbrk for win32.
++  Donated by J. Walter <Walter@GeNeSys-e.de>.
++  For additional information about this code, and malloc on Win32, see
++     http://www.genesys-e.de/jwalter/
++*/
++
++
++#ifdef WIN32
++
++#ifdef _DEBUG
++/* #define TRACE */
++#endif
++
++/* Support for USE_MALLOC_LOCK */
++#ifdef USE_MALLOC_LOCK
++
++/* Wait for spin lock */
++static int slwait (int *sl) {
++    while (InterlockedCompareExchange ((void **) sl, (void *) 1, (void *) 0) != 0)
++	    Sleep (0);
++    return 0;
++}
++
++/* Release spin lock */
++static int slrelease (int *sl) {
++    InterlockedExchange (sl, 0);
++    return 0;
++}
++
++#ifdef NEEDED
++/* Spin lock for emulation code */
++static int g_sl;
++#endif
++
++#endif /* USE_MALLOC_LOCK */
++
++/* getpagesize for windows */
++static long getpagesize (void) {
++    static long g_pagesize = 0;
++    if (! g_pagesize) {
++        SYSTEM_INFO system_info;
++        GetSystemInfo (&system_info);
++        g_pagesize = system_info.dwPageSize;
++    }
++    return g_pagesize;
++}
++static long getregionsize (void) {
++    static long g_regionsize = 0;
++    if (! g_regionsize) {
++        SYSTEM_INFO system_info;
++        GetSystemInfo (&system_info);
++        g_regionsize = system_info.dwAllocationGranularity;
++    }
++    return g_regionsize;
++}
++
++/* A region list entry */
++typedef struct _region_list_entry {
++    void *top_allocated;
++    void *top_committed;
++    void *top_reserved;
++    long reserve_size;
++    struct _region_list_entry *previous;
++} region_list_entry;
++
++/* Allocate and link a region entry in the region list */
++static int region_list_append (region_list_entry **last, void *base_reserved, long reserve_size) {
++    region_list_entry *next = HeapAlloc (GetProcessHeap (), 0, sizeof (region_list_entry));
++    if (! next)
++        return FALSE;
++    next->top_allocated = (char *) base_reserved;
++    next->top_committed = (char *) base_reserved;
++    next->top_reserved = (char *) base_reserved + reserve_size;
++    next->reserve_size = reserve_size;
++    next->previous = *last;
++    *last = next;
++    return TRUE;
++}
++/* Free and unlink the last region entry from the region list */
++static int region_list_remove (region_list_entry **last) {
++    region_list_entry *previous = (*last)->previous;
++    if (! HeapFree (GetProcessHeap (), sizeof (region_list_entry), *last))
++        return FALSE;
++    *last = previous;
++    return TRUE;
++}
++
++#define CEIL(size,to)	(((size)+(to)-1)&~((to)-1))
++#define FLOOR(size,to)	((size)&~((to)-1))
++
++#define SBRK_SCALE  0
++/* #define SBRK_SCALE  1 */
++/* #define SBRK_SCALE  2 */
++/* #define SBRK_SCALE  4  */
++
++/* sbrk for windows */
++static void *sbrk (long size) {
++    static long g_pagesize, g_my_pagesize;
++    static long g_regionsize, g_my_regionsize;
++    static region_list_entry *g_last;
++    void *result = (void *) MORECORE_FAILURE;
++#ifdef TRACE
++    printf ("sbrk %d\n", size);
++#endif
++#if defined (USE_MALLOC_LOCK) && defined (NEEDED)
++    /* Wait for spin lock */
++    slwait (&g_sl);
++#endif
++    /* First time initialization */
++    if (! g_pagesize) {
++        g_pagesize = getpagesize ();
++        g_my_pagesize = g_pagesize << SBRK_SCALE;
++    }
++    if (! g_regionsize) {
++        g_regionsize = getregionsize ();
++        g_my_regionsize = g_regionsize << SBRK_SCALE;
++    }
++    if (! g_last) {
++        if (! region_list_append (&g_last, 0, 0))
++           goto sbrk_exit;
++    }
++    /* Assert invariants */
++    assert (g_last);
++    assert ((char *) g_last->top_reserved - g_last->reserve_size <= (char *) g_last->top_allocated &&
++            g_last->top_allocated <= g_last->top_committed);
++    assert ((char *) g_last->top_reserved - g_last->reserve_size <= (char *) g_last->top_committed &&
++            g_last->top_committed <= g_last->top_reserved &&
++            (unsigned) g_last->top_committed % g_pagesize == 0);
++    assert ((unsigned) g_last->top_reserved % g_regionsize == 0);
++    assert ((unsigned) g_last->reserve_size % g_regionsize == 0);
++    /* Allocation requested? */
++    if (size >= 0) {
++        /* Allocation size is the requested size */
++        long allocate_size = size;
++        /* Compute the size to commit */
++        long to_commit = (char *) g_last->top_allocated + allocate_size - (char *) g_last->top_committed;
++        /* Do we reach the commit limit? */
++        if (to_commit > 0) {
++            /* Round size to commit */
++            long commit_size = CEIL (to_commit, g_my_pagesize);
++            /* Compute the size to reserve */
++            long to_reserve = (char *) g_last->top_committed + commit_size - (char *) g_last->top_reserved;
++            /* Do we reach the reserve limit? */
++            if (to_reserve > 0) {
++                /* Compute the remaining size to commit in the current region */
++                long remaining_commit_size = (char *) g_last->top_reserved - (char *) g_last->top_committed;
++                if (remaining_commit_size > 0) {
++                    /* Assert preconditions */
++                    assert ((unsigned) g_last->top_committed % g_pagesize == 0);
++                    assert (0 < remaining_commit_size && remaining_commit_size % g_pagesize == 0); {
++                        /* Commit this */
++                        void *base_committed = VirtualAlloc (g_last->top_committed, remaining_commit_size,
++							                                 MEM_COMMIT, PAGE_READWRITE);
++                        /* Check returned pointer for consistency */
++                        if (base_committed != g_last->top_committed)
++                            goto sbrk_exit;
++                        /* Assert postconditions */
++                        assert ((unsigned) base_committed % g_pagesize == 0);
++#ifdef TRACE
++                        printf ("Commit %p %d\n", base_committed, remaining_commit_size);
++#endif
++                        /* Adjust the regions commit top */
++                        g_last->top_committed = (char *) base_committed + remaining_commit_size;
++                    }
++                } {
++                    /* Now we are going to search and reserve. */
++                    int contiguous = -1;
++                    int found = FALSE;
++                    MEMORY_BASIC_INFORMATION memory_info;
++                    void *base_reserved;
++                    long reserve_size;
++                    do {
++                        /* Assume contiguous memory */
++                        contiguous = TRUE;
++                        /* Round size to reserve */
++                        reserve_size = CEIL (to_reserve, g_my_regionsize);
++                        /* Start with the current region's top */
++                        memory_info.BaseAddress = g_last->top_reserved;
++                        /* Assert preconditions */
++                        assert ((unsigned) memory_info.BaseAddress % g_pagesize == 0);
++                        assert (0 < reserve_size && reserve_size % g_regionsize == 0);
++                        while (VirtualQuery (memory_info.BaseAddress, &memory_info, sizeof (memory_info))) {
++                            /* Assert postconditions */
++                            assert ((unsigned) memory_info.BaseAddress % g_pagesize == 0);
++#ifdef TRACE
++                            printf ("Query %p %d %s\n", memory_info.BaseAddress, memory_info.RegionSize,
++                                    memory_info.State == MEM_FREE ? "FREE":
++                                    (memory_info.State == MEM_RESERVE ? "RESERVED":
++                                     (memory_info.State == MEM_COMMIT ? "COMMITTED": "?")));
++#endif
++                            /* Region is free, well aligned and big enough: we are done */
++                            if (memory_info.State == MEM_FREE &&
++                                (unsigned) memory_info.BaseAddress % g_regionsize == 0 &&
++                                memory_info.RegionSize >= (unsigned) reserve_size) {
++                                found = TRUE;
++                                break;
++                            }
++                            /* From now on we can't get contiguous memory! */
++                            contiguous = FALSE;
++                            /* Recompute size to reserve */
++                            reserve_size = CEIL (allocate_size, g_my_regionsize);
++                            memory_info.BaseAddress = (char *) memory_info.BaseAddress + memory_info.RegionSize;
++                            /* Assert preconditions */
++                            assert ((unsigned) memory_info.BaseAddress % g_pagesize == 0);
++                            assert (0 < reserve_size && reserve_size % g_regionsize == 0);
++                        }
++                        /* Search failed? */
++                        if (! found)
++                            goto sbrk_exit;
++                        /* Assert preconditions */
++                        assert ((unsigned) memory_info.BaseAddress % g_regionsize == 0);
++                        assert (0 < reserve_size && reserve_size % g_regionsize == 0);
++                        /* Try to reserve this */
++                        base_reserved = VirtualAlloc (memory_info.BaseAddress, reserve_size,
++					                                  MEM_RESERVE, PAGE_NOACCESS);
++                        if (! base_reserved) {
++                            int rc = GetLastError ();
++                            if (rc != ERROR_INVALID_ADDRESS)
++                                goto sbrk_exit;
++                        }
++                        /* A null pointer signals (hopefully) a race condition with another thread. */
++                        /* In this case, we try again. */
++                    } while (! base_reserved);
++                    /* Check returned pointer for consistency */
++                    if (memory_info.BaseAddress && base_reserved != memory_info.BaseAddress)
++                        goto sbrk_exit;
++                    /* Assert postconditions */
++                    assert ((unsigned) base_reserved % g_regionsize == 0);
++#ifdef TRACE
++                    printf ("Reserve %p %d\n", base_reserved, reserve_size);
++#endif
++                    /* Did we get contiguous memory? */
++                    if (contiguous) {
++                        long start_size = (char *) g_last->top_committed - (char *) g_last->top_allocated;
++                        /* Adjust allocation size */
++                        allocate_size -= start_size;
++                        /* Adjust the regions allocation top */
++                        g_last->top_allocated = g_last->top_committed;
++                        /* Recompute the size to commit */
++                        to_commit = (char *) g_last->top_allocated + allocate_size - (char *) g_last->top_committed;
++                        /* Round size to commit */
++                        commit_size = CEIL (to_commit, g_my_pagesize);
++                    }
++                    /* Append the new region to the list */
++                    if (! region_list_append (&g_last, base_reserved, reserve_size))
++                        goto sbrk_exit;
++                    /* Didn't we get contiguous memory? */
++                    if (! contiguous) {
++                        /* Recompute the size to commit */
++                        to_commit = (char *) g_last->top_allocated + allocate_size - (char *) g_last->top_committed;
++                        /* Round size to commit */
++                        commit_size = CEIL (to_commit, g_my_pagesize);
++                    }
++                }
++            }
++            /* Assert preconditions */
++            assert ((unsigned) g_last->top_committed % g_pagesize == 0);
++            assert (0 < commit_size && commit_size % g_pagesize == 0); {
++                /* Commit this */
++                void *base_committed = VirtualAlloc (g_last->top_committed, commit_size,
++							                     MEM_COMMIT, PAGE_READWRITE);
++                /* Check returned pointer for consistency */
++                if (base_committed != g_last->top_committed)
++                    goto sbrk_exit;
++                /* Assert postconditions */
++                assert ((unsigned) base_committed % g_pagesize == 0);
++#ifdef TRACE
++                printf ("Commit %p %d\n", base_committed, commit_size);
++#endif
++                /* Adjust the regions commit top */
++                g_last->top_committed = (char *) base_committed + commit_size;
++            }
++        }
++        /* Adjust the regions allocation top */
++        g_last->top_allocated = (char *) g_last->top_allocated + allocate_size;
++        result = (char *) g_last->top_allocated - size;
++    /* Deallocation requested? */
++    } else if (size < 0) {
++        long deallocate_size = - size;
++        /* As long as we have a region to release */
++        while ((char *) g_last->top_allocated - deallocate_size < (char *) g_last->top_reserved - g_last->reserve_size) {
++            /* Get the size to release */
++            long release_size = g_last->reserve_size;
++            /* Get the base address */
++            void *base_reserved = (char *) g_last->top_reserved - release_size;
++            /* Assert preconditions */
++            assert ((unsigned) base_reserved % g_regionsize == 0);
++            assert (0 < release_size && release_size % g_regionsize == 0); {
++                /* Release this */
++                int rc = VirtualFree (base_reserved, 0,
++                                      MEM_RELEASE);
++                /* Check returned code for consistency */
++                if (! rc)
++                    goto sbrk_exit;
++#ifdef TRACE
++                printf ("Release %p %d\n", base_reserved, release_size);
++#endif
++            }
++            /* Adjust deallocation size */
++            deallocate_size -= (char *) g_last->top_allocated - (char *) base_reserved;
++            /* Remove the old region from the list */
++            if (! region_list_remove (&g_last))
++                goto sbrk_exit;
++        } {
++            /* Compute the size to decommit */
++            long to_decommit = (char *) g_last->top_committed - ((char *) g_last->top_allocated - deallocate_size);
++            if (to_decommit >= g_my_pagesize) {
++                /* Compute the size to decommit */
++                long decommit_size = FLOOR (to_decommit, g_my_pagesize);
++                /*  Compute the base address */
++                void *base_committed = (char *) g_last->top_committed - decommit_size;
++                /* Assert preconditions */
++                assert ((unsigned) base_committed % g_pagesize == 0);
++                assert (0 < decommit_size && decommit_size % g_pagesize == 0); {
++                    /* Decommit this */
++                    int rc = VirtualFree ((char *) base_committed, decommit_size,
++                                          MEM_DECOMMIT);
++                    /* Check returned code for consistency */
++                    if (! rc)
++                        goto sbrk_exit;
++#ifdef TRACE
++                    printf ("Decommit %p %d\n", base_committed, decommit_size);
++#endif
++                }
++                /* Adjust deallocation size and regions commit and allocate top */
++                deallocate_size -= (char *) g_last->top_allocated - (char *) base_committed;
++                g_last->top_committed = base_committed;
++                g_last->top_allocated = base_committed;
++            }
++        }
++        /* Adjust regions allocate top */
++        g_last->top_allocated = (char *) g_last->top_allocated - deallocate_size;
++        /* Check for underflow */
++        if ((char *) g_last->top_reserved - g_last->reserve_size > (char *) g_last->top_allocated ||
++            g_last->top_allocated > g_last->top_committed) {
++            /* Adjust regions allocate top */
++            g_last->top_allocated = (char *) g_last->top_reserved - g_last->reserve_size;
++            goto sbrk_exit;
++        }
++        result = g_last->top_allocated;
++    }
++    /* Assert invariants */
++    assert (g_last);
++    assert ((char *) g_last->top_reserved - g_last->reserve_size <= (char *) g_last->top_allocated &&
++            g_last->top_allocated <= g_last->top_committed);
++    assert ((char *) g_last->top_reserved - g_last->reserve_size <= (char *) g_last->top_committed &&
++            g_last->top_committed <= g_last->top_reserved &&
++            (unsigned) g_last->top_committed % g_pagesize == 0);
++    assert ((unsigned) g_last->top_reserved % g_regionsize == 0);
++    assert ((unsigned) g_last->reserve_size % g_regionsize == 0);
++
++sbrk_exit:
++#if defined (USE_MALLOC_LOCK) && defined (NEEDED)
++    /* Release spin lock */
++    slrelease (&g_sl);
++#endif
++    return result;
++}
++
++/* mmap for windows */
++static void *mmap (void *ptr, long size, long prot, long type, long handle, long arg) {
++    static long g_pagesize;
++    static long g_regionsize;
++#ifdef TRACE
++    printf ("mmap %d\n", size);
++#endif
++#if defined (USE_MALLOC_LOCK) && defined (NEEDED)
++    /* Wait for spin lock */
++    slwait (&g_sl);
++#endif
++    /* First time initialization */
++    if (! g_pagesize)
++        g_pagesize = getpagesize ();
++    if (! g_regionsize)
++        g_regionsize = getregionsize ();
++    /* Assert preconditions */
++    assert ((unsigned) ptr % g_regionsize == 0);
++    assert (size % g_pagesize == 0);
++    /* Allocate this */
++    ptr = VirtualAlloc (ptr, size,
++					    MEM_RESERVE | MEM_COMMIT | MEM_TOP_DOWN, PAGE_READWRITE);
++    if (! ptr) {
++        ptr = (void *) MORECORE_FAILURE;
++        goto mmap_exit;
++    }
++    /* Assert postconditions */
++    assert ((unsigned) ptr % g_regionsize == 0);
++#ifdef TRACE
++    printf ("Commit %p %d\n", ptr, size);
++#endif
++mmap_exit:
++#if defined (USE_MALLOC_LOCK) && defined (NEEDED)
++    /* Release spin lock */
++    slrelease (&g_sl);
++#endif
++    return ptr;
++}
++
++/* munmap for windows */
++static long munmap (void *ptr, long size) {
++    static long g_pagesize;
++    static long g_regionsize;
++    int rc = MUNMAP_FAILURE;
++#ifdef TRACE
++    printf ("munmap %p %d\n", ptr, size);
++#endif
++#if defined (USE_MALLOC_LOCK) && defined (NEEDED)
++    /* Wait for spin lock */
++    slwait (&g_sl);
++#endif
++    /* First time initialization */
++    if (! g_pagesize)
++        g_pagesize = getpagesize ();
++    if (! g_regionsize)
++        g_regionsize = getregionsize ();
++    /* Assert preconditions */
++    assert ((unsigned) ptr % g_regionsize == 0);
++    assert (size % g_pagesize == 0);
++    /* Free this */
++    if (! VirtualFree (ptr, 0,
++                       MEM_RELEASE))
++        goto munmap_exit;
++    rc = 0;
++#ifdef TRACE
++    printf ("Release %p %d\n", ptr, size);
++#endif
++munmap_exit:
++#if defined (USE_MALLOC_LOCK) && defined (NEEDED)
++    /* Release spin lock */
++    slrelease (&g_sl);
++#endif
++    return rc;
++}
++
++static void vminfo (unsigned long *free, unsigned long *reserved, unsigned long *committed) {
++    MEMORY_BASIC_INFORMATION memory_info;
++    memory_info.BaseAddress = 0;
++    *free = *reserved = *committed = 0;
++    while (VirtualQuery (memory_info.BaseAddress, &memory_info, sizeof (memory_info))) {
++        switch (memory_info.State) {
++        case MEM_FREE:
++            *free += memory_info.RegionSize;
++            break;
++        case MEM_RESERVE:
++            *reserved += memory_info.RegionSize;
++            break;
++        case MEM_COMMIT:
++            *committed += memory_info.RegionSize;
++            break;
++        }
++        memory_info.BaseAddress = (char *) memory_info.BaseAddress + memory_info.RegionSize;
++    }
++}
++
++static int cpuinfo (int whole, unsigned long *kernel, unsigned long *user) {
++    if (whole) {
++        __int64 creation64, exit64, kernel64, user64;
++        int rc = GetProcessTimes (GetCurrentProcess (),
++                                  (FILETIME *) &creation64,
++                                  (FILETIME *) &exit64,
++                                  (FILETIME *) &kernel64,
++                                  (FILETIME *) &user64);
++        if (! rc) {
++            *kernel = 0;
++            *user = 0;
++            return FALSE;
++        }
++        *kernel = (unsigned long) (kernel64 / 10000);
++        *user = (unsigned long) (user64 / 10000);
++        return TRUE;
++    } else {
++        __int64 creation64, exit64, kernel64, user64;
++        int rc = GetThreadTimes (GetCurrentThread (),
++                                 (FILETIME *) &creation64,
++                                 (FILETIME *) &exit64,
++                                 (FILETIME *) &kernel64,
++                                 (FILETIME *) &user64);
++        if (! rc) {
++            *kernel = 0;
++            *user = 0;
++            return FALSE;
++        }
++        *kernel = (unsigned long) (kernel64 / 10000);
++        *user = (unsigned long) (user64 / 10000);
++        return TRUE;
++    }
++}
++
++#endif /* WIN32 */
++
++/* ------------------------------------------------------------
++History:
++
++    V2.7.0 Sun Mar 11 14:14:06 2001  Doug Lea  (dl at gee)
++      * Introduce independent_comalloc and independent_calloc.
++        Thanks to Michael Pachos for motivation and help.
++      * Make optional .h file available
++      * Allow > 2GB requests on 32bit systems.
++      * new WIN32 sbrk, mmap, munmap, lock code from <Walter@GeNeSys-e.de>.
++        Thanks also to Andreas Mueller <a.mueller at paradatec.de>,
++        and Anonymous.
++      * Allow override of MALLOC_ALIGNMENT (Thanks to Ruud Waij for
++        helping test this.)
++      * memalign: check alignment arg
++      * realloc: don't try to shift chunks backwards, since this
++        leads to  more fragmentation in some programs and doesn't
++        seem to help in any others.
++      * Collect all cases in malloc requiring system memory into sYSMALLOc
++      * Use mmap as backup to sbrk
++      * Place all internal state in malloc_state
++      * Introduce fastbins (although similar to 2.5.1)
++      * Many minor tunings and cosmetic improvements
++      * Introduce USE_PUBLIC_MALLOC_WRAPPERS, USE_MALLOC_LOCK
++      * Introduce MALLOC_FAILURE_ACTION, MORECORE_CONTIGUOUS
++        Thanks to Tony E. Bennett <tbennett@nvidia.com> and others.
++      * Include errno.h to support default failure action.
++
++    V2.6.6 Sun Dec  5 07:42:19 1999  Doug Lea  (dl at gee)
++      * return null for negative arguments
++      * Added Several WIN32 cleanups from Martin C. Fong <mcfong at yahoo.com>
++         * Add 'LACKS_SYS_PARAM_H' for those systems without 'sys/param.h'
++          (e.g. WIN32 platforms)
++         * Cleanup header file inclusion for WIN32 platforms
++         * Cleanup code to avoid Microsoft Visual C++ compiler complaints
++         * Add 'USE_DL_PREFIX' to quickly allow co-existence with existing
++           memory allocation routines
++         * Set 'malloc_getpagesize' for WIN32 platforms (needs more work)
++         * Use 'assert' rather than 'ASSERT' in WIN32 code to conform to
++           usage of 'assert' in non-WIN32 code
++         * Improve WIN32 'sbrk()' emulation's 'findRegion()' routine to
++           avoid infinite loop
++      * Always call 'fREe()' rather than 'free()'
++
++    V2.6.5 Wed Jun 17 15:57:31 1998  Doug Lea  (dl at gee)
++      * Fixed ordering problem with boundary-stamping
++
++    V2.6.3 Sun May 19 08:17:58 1996  Doug Lea  (dl at gee)
++      * Added pvalloc, as recommended by H.J. Liu
++      * Added 64bit pointer support mainly from Wolfram Gloger
++      * Added anonymously donated WIN32 sbrk emulation
++      * Malloc, calloc, getpagesize: add optimizations from Raymond Nijssen
++      * malloc_extend_top: fix mask error that caused wastage after
++        foreign sbrks
++      * Add linux mremap support code from HJ Liu
++
++    V2.6.2 Tue Dec  5 06:52:55 1995  Doug Lea  (dl at gee)
++      * Integrated most documentation with the code.
++      * Add support for mmap, with help from
++        Wolfram Gloger (Gloger@lrz.uni-muenchen.de).
++      * Use last_remainder in more cases.
++      * Pack bins using idea from  colin@nyx10.cs.du.edu
++      * Use ordered bins instead of best-fit threshold
++      * Eliminate block-local decls to simplify tracing and debugging.
++      * Support another case of realloc via move into top
++      * Fix error occurring when initial sbrk_base not word-aligned.
++      * Rely on page size for units instead of SBRK_UNIT to
++        avoid surprises about sbrk alignment conventions.
++      * Add mallinfo, mallopt. Thanks to Raymond Nijssen
++        (raymond@es.ele.tue.nl) for the suggestion.
++      * Add `pad' argument to malloc_trim and top_pad mallopt parameter.
++      * More precautions for cases where other routines call sbrk,
++        courtesy of Wolfram Gloger (Gloger@lrz.uni-muenchen.de).
++      * Added macros etc., allowing use in linux libc from
++        H.J. Lu (hjl@gnu.ai.mit.edu)
++      * Inverted this history list
++
++    V2.6.1 Sat Dec  2 14:10:57 1995  Doug Lea  (dl at gee)
++      * Re-tuned and fixed to behave more nicely with V2.6.0 changes.
++      * Removed all preallocation code since under current scheme
++        the work required to undo bad preallocations exceeds
++        the work saved in good cases for most test programs.
++      * No longer use return list or unconsolidated bins since
++        no scheme using them consistently outperforms those that don't
++        given above changes.
++      * Use best fit for very large chunks to prevent some worst-cases.
++      * Added some support for debugging
++
++    V2.6.0 Sat Nov  4 07:05:23 1995  Doug Lea  (dl at gee)
++      * Removed footers when chunks are in use. Thanks to
++        Paul Wilson (wilson@cs.texas.edu) for the suggestion.
++
++    V2.5.4 Wed Nov  1 07:54:51 1995  Doug Lea  (dl at gee)
++      * Added malloc_trim, with help from Wolfram Gloger
++        (wmglo@Dent.MED.Uni-Muenchen.DE).
++
++    V2.5.3 Tue Apr 26 10:16:01 1994  Doug Lea  (dl at g)
++
++    V2.5.2 Tue Apr  5 16:20:40 1994  Doug Lea  (dl at g)
++      * realloc: try to expand in both directions
++      * malloc: swap order of clean-bin strategy;
++      * realloc: only conditionally expand backwards
++      * Try not to scavenge used bins
++      * Use bin counts as a guide to preallocation
++      * Occasionally bin return list chunks in first scan
++      * Add a few optimizations from colin@nyx10.cs.du.edu
++
++    V2.5.1 Sat Aug 14 15:40:43 1993  Doug Lea  (dl at g)
++      * faster bin computation & slightly different binning
++      * merged all consolidations to one part of malloc proper
++         (eliminating old malloc_find_space & malloc_clean_bin)
++      * Scan 2 returns chunks (not just 1)
++      * Propagate failure in realloc if malloc returns 0
++      * Add stuff to allow compilation on non-ANSI compilers
++          from kpv@research.att.com
++
++    V2.5 Sat Aug  7 07:41:59 1993  Doug Lea  (dl at g.oswego.edu)
++      * removed potential for odd address access in prev_chunk
++      * removed dependency on getpagesize.h
++      * misc cosmetics and a bit more internal documentation
++      * anticosmetics: mangled names in macros to evade debugger strangeness
++      * tested on sparc, hp-700, dec-mips, rs6000
++          with gcc & native cc (hp, dec only) allowing
++          Detlefs & Zorn comparison study (in SIGPLAN Notices.)
++
++    Trial version Fri Aug 28 13:14:29 1992  Doug Lea  (dl at g.oswego.edu)
++      * Based loosely on libg++-1.2X malloc. (It retains some of the overall
++         structure of old version,  but most details differ.)
++
++*/
++
++#ifdef USE_PUBLIC_MALLOC_WRAPPERS
++
++#ifndef KDE_MALLOC_FULL
++
++#ifdef KDE_MALLOC_GLIBC
++#include "glibc.h"
++#else
++/* cannot use dlsym(RTLD_NEXT,...) here, it calls malloc()*/
++#error Unknown libc
++#endif
++
++/* 0 - uninitialized
++   1 - this malloc
++   2 - standard libc malloc*/
++extern char* getenv(const char*);
++static int malloc_type = 0;
++static void init_malloc_type(void)
++    {
++    const char* const env = getenv( "KDE_MALLOC" );
++    if( env == NULL )
++        malloc_type = 1;
++    else if( env[ 0 ] == '0' || env[ 0 ] == 'n' || env[ 0 ] == 'N' )
++        malloc_type = 2;
++    else
++        malloc_type = 1;
++    }
++
++#endif
++
++Void_t* public_mALLOc(size_t bytes) {
++#ifndef KDE_MALLOC_FULL
++  if( malloc_type == 1 )
++    {
++#endif
++  Void_t* m;
++  if (MALLOC_PREACTION != 0) {
++    return 0;
++  }
++  m = mALLOc(bytes);
++  if (MALLOC_POSTACTION != 0) {
++  }
++  return m;
++#ifndef KDE_MALLOC_FULL
++    }
++  if( malloc_type == 2 )
++      return libc_malloc( bytes );
++  init_malloc_type();
++  return public_mALLOc( bytes );
++#endif
++}
++
++void public_fREe(Void_t* m) {
++#ifndef KDE_MALLOC_FULL
++  if( malloc_type == 1 )
++    {
++#endif
++  if (MALLOC_PREACTION != 0) {
++    return;
++  }
++  fREe(m);
++  if (MALLOC_POSTACTION != 0) {
++  }
++#ifndef KDE_MALLOC_FULL
++  return;
++    }
++  if( malloc_type == 2 )
++      {
++      libc_free( m );
++      return;
++      }
++  init_malloc_type();
++  public_fREe( m );
++#endif
++}
++
++Void_t* public_rEALLOc(Void_t* m, size_t bytes) {
++#ifndef KDE_MALLOC_FULL
++  if( malloc_type == 1 )
++    {
++#endif
++  if (MALLOC_PREACTION != 0) {
++    return 0;
++  }
++  m = rEALLOc(m, bytes);
++  if (MALLOC_POSTACTION != 0) {
++  }
++  return m;
++#ifndef KDE_MALLOC_FULL
++    }
++  if( malloc_type == 2 )
++      return libc_realloc( m, bytes );
++  init_malloc_type();
++  return public_rEALLOc( m, bytes );
++#endif
++}
++
++Void_t* public_mEMALIGn(size_t alignment, size_t bytes) {
++#ifndef KDE_MALLOC_FULL
++  if( malloc_type == 1 )
++    {
++#endif
++  Void_t* m;
++  if (MALLOC_PREACTION != 0) {
++    return 0;
++  }
++  m = mEMALIGn(alignment, bytes);
++  if (MALLOC_POSTACTION != 0) {
++  }
++  return m;
++#ifndef KDE_MALLOC_FULL
++    }
++  if( malloc_type == 2 )
++      return libc_memalign( alignment, bytes );
++  init_malloc_type();
++  return public_mEMALIGn( alignment, bytes );
++#endif
++}
++
++Void_t* public_vALLOc(size_t bytes) {
++#ifndef KDE_MALLOC_FULL
++  if( malloc_type == 1 )
++    {
++#endif
++  Void_t* m;
++  if (MALLOC_PREACTION != 0) {
++    return 0;
++  }
++  m = vALLOc(bytes);
++  if (MALLOC_POSTACTION != 0) {
++  }
++  return m;
++#ifndef KDE_MALLOC_FULL
++    }
++  if( malloc_type == 2 )
++      return libc_valloc( bytes );
++  init_malloc_type();
++  return public_vALLOc( bytes );
++#endif
++}
++
++Void_t* public_pVALLOc(size_t bytes) {
++#ifndef KDE_MALLOC_FULL
++  if( malloc_type == 1 )
++    {
++#endif
++  Void_t* m;
++  if (MALLOC_PREACTION != 0) {
++    return 0;
++  }
++  m = pVALLOc(bytes);
++  if (MALLOC_POSTACTION != 0) {
++  }
++  return m;
++#ifndef KDE_MALLOC_FULL
++    }
++  if( malloc_type == 2 )
++      return libc_pvalloc( bytes );
++  init_malloc_type();
++  return public_pVALLOc( bytes );
++#endif
++}
++
++Void_t* public_cALLOc(size_t n, size_t elem_size) {
++#ifndef KDE_MALLOC_FULL
++  if( malloc_type == 1 )
++    {
++#endif
++  Void_t* m;
++  if (MALLOC_PREACTION != 0) {
++    return 0;
++  }
++  m = cALLOc(n, elem_size);
++  if (MALLOC_POSTACTION != 0) {
++  }
++  return m;
++#ifndef KDE_MALLOC_FULL
++    }
++  if( malloc_type == 2 )
++      return libc_calloc( n, elem_size );
++  init_malloc_type();
++  return public_cALLOc( n, elem_size );
++#endif
++}
++
++void public_cFREe(Void_t* m) {
++#ifndef KDE_MALLOC_FULL
++  if( malloc_type == 1 )
++    {
++#endif
++  if (MALLOC_PREACTION != 0) {
++    return;
++  }
++  cFREe(m);
++  if (MALLOC_POSTACTION != 0) {
++  }
++#ifndef KDE_MALLOC_FULL
++  return;
++    }
++  if( malloc_type == 2 )
++      {
++      libc_cfree( m );
++      return;
++      }
++  init_malloc_type();
++  public_cFREe( m );
++#endif
++}
++
++struct mallinfo public_mALLINFo() {
++#ifndef KDE_MALLOC_FULL
++  if( malloc_type == 1 )
++    {
++#endif
++  struct mallinfo m;
++  if (MALLOC_PREACTION != 0) {
++    struct mallinfo nm = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
++    return nm;
++  }
++  m = mALLINFo();
++  if (MALLOC_POSTACTION != 0) {
++  }
++  return m;
++#ifndef KDE_MALLOC_FULL
++    }
++  if( malloc_type == 2 )
++      return libc_mallinfo();
++  init_malloc_type();
++  return public_mALLINFo();
++#endif
++}
++
++int public_mALLOPt(int p, int v) {
++#ifndef KDE_MALLOC_FULL
++  if( malloc_type == 1 )
++    {
++#endif
++  int result;
++  if (MALLOC_PREACTION != 0) {
++    return 0;
++  }
++  result = mALLOPt(p, v);
++  if (MALLOC_POSTACTION != 0) {
++  }
++  return result;
++#ifndef KDE_MALLOC_FULL
++    }
++  if( malloc_type == 2 )
++      return libc_mallopt( p, v );
++  init_malloc_type();
++  return public_mALLOPt( p, v );
++#endif
++}
++#endif
++
++int
++posix_memalign (void **memptr, size_t alignment, size_t size)
++{
++  void *mem;
++
++  /* Test whether the SIZE argument is valid.  It must be a power of
++     two multiple of sizeof (void *).  */
++  if (size % sizeof (void *) != 0 || (size & (size - 1)) != 0)
++    return EINVAL;
++
++  mem = memalign (alignment, size);
++
++  if (mem != NULL) {
++    *memptr = mem;
++    return 0;
++  }
++
++  return ENOMEM;
++}
++
++#else
++/* Some linkers (Solaris 2.6) don't like empty archives, but for
++   easier Makefile's we want to link against libklmalloc.la every time,
++   so simply make it non-empty.  */
++void kde_malloc_dummy_function ()
++{
++  return;
++}
++#endif
+diff -Nupr a/src/corelib/arch/avr32/qatomic.cpp b/src/corelib/arch/avr32/qatomic.cpp
+--- a/src/corelib/arch/avr32/qatomic.cpp	1970-01-01 01:00:00.000000000 +0100
++++ b/src/corelib/arch/avr32/qatomic.cpp	2006-07-26 11:02:43.000000000 +0200
+@@ -0,0 +1,24 @@
++/****************************************************************************
++**
++** Copyright (C) 1992-2006 Trolltech ASA. All rights reserved.
++**
++** This file is part of the QtCore module of the Qt Toolkit.
++**
++** Licensees holding valid Qt Preview licenses may use this file in
++** accordance with the Qt Preview License Agreement provided with the
++** Software.
++**
++** See http://www.trolltech.com/pricing.html or email sales@trolltech.com for
++** information about Qt Commercial License Agreements.
++**
++** Contact info@trolltech.com if any conditions of this licensing are
++** not clear to you.
++**
++** This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
++** WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
++**
++****************************************************************************/
++
++#include "QtCore/qatomic_avr32.h"
++
++Q_CORE_EXPORT long q_atomic_lock = 0;
+diff -Nupr a/src/corelib/arch/qatomic_arch.h b/src/corelib/arch/qatomic_arch.h
+--- a/src/corelib/arch/qatomic_arch.h	2006-06-30 09:49:44.000000000 +0200
++++ b/src/corelib/arch/qatomic_arch.h	2006-07-27 12:42:58.000000000 +0200
+@@ -32,6 +32,8 @@ QT_BEGIN_HEADER
+ #  include "QtCore/qatomic_alpha.h"
+ #elif defined(QT_ARCH_ARM)
+ #  include "QtCore/qatomic_arm.h"
++#elif defined(QT_ARCH_AVR32)
++#  include "QtCore/qatomic_avr32.h"
+ #elif defined(QT_ARCH_BOUNDSCHECKER)
+ #  include "QtCore/qatomic_boundschecker.h"
+ #elif defined(QT_ARCH_GENERIC)
+diff -Nupr a/src/corelib/arch/qatomic_avr32.h b/src/corelib/arch/qatomic_avr32.h
+--- a/src/corelib/arch/qatomic_avr32.h	1970-01-01 01:00:00.000000000 +0100
++++ b/src/corelib/arch/qatomic_avr32.h	2006-07-28 10:30:08.000000000 +0200
+@@ -0,0 +1,113 @@
++/****************************************************************************
++**
++** Copyright (C) 1992-2006 Trolltech ASA. All rights reserved.
++**
++** This file is part of the QtCore module of the Qt Toolkit.
++**
++** Licensees holding valid Qt Preview licenses may use this file in
++** accordance with the Qt Preview License Agreement provided with the
++** Software.
++**
++** See http://www.trolltech.com/pricing.html or email sales@trolltech.com for
++** information about Qt Commercial License Agreements.
++**
++** Contact info@trolltech.com if any conditions of this licensing are
++** not clear to you.
++**
++** This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
++** WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
++**
++****************************************************************************/
++
++#ifndef AVR32_QATOMIC_H
++#define AVR32_QATOMIC_H
++
++#include <QtCore/qglobal.h>
++
++QT_BEGIN_HEADER
++
++extern Q_CORE_EXPORT long q_atomic_lock;
++
++inline long q_atomic_swp(volatile long *ptr, long newval)
++{
++    register int ret;
++    asm volatile("xchg %0,%1,%2"
++                 : "=&r"(ret)
++                 : "r"(ptr), "r"(newval)
++                 : "memory", "cc");
++    return ret;
++}
++
++inline int q_atomic_test_and_set_int(volatile int *ptr, int expected, int newval)
++{
++    int ret = 0;
++    while (q_atomic_swp(&q_atomic_lock, ~0) != 0);
++    if (*ptr == expected) {
++	*ptr = newval;
++	ret = 1;
++    }
++    q_atomic_swp(&q_atomic_lock, 0);
++    return ret;
++}
++
++inline int q_atomic_test_and_set_acquire_int(volatile int *ptr, int expected, int newval)
++{
++    return q_atomic_test_and_set_int(ptr, expected, newval);
++}
++
++inline int q_atomic_test_and_set_release_int(volatile int *ptr, int expected, int newval)
++{
++    return q_atomic_test_and_set_int(ptr, expected, newval);
++}
++
++inline int q_atomic_test_and_set_ptr(volatile void *ptr, void *expected, void *newval)
++{
++    int ret = 0;
++    while (q_atomic_swp(&q_atomic_lock, ~0) != 0) ;
++    if (*reinterpret_cast<void * volatile *>(ptr) == expected) {
++	*reinterpret_cast<void * volatile *>(ptr) = newval;
++	ret = 1;
++    }
++    q_atomic_swp(&q_atomic_lock, 0);
++    return ret;
++}
++
++inline int q_atomic_increment(volatile int *ptr)
++{
++    while (q_atomic_swp(&q_atomic_lock, ~0) != 0) ;
++    int originalValue = *ptr;
++    *ptr = originalValue + 1;
++    q_atomic_swp(&q_atomic_lock, 0);
++    return originalValue != -1;
++}
++
++inline int q_atomic_decrement(volatile int *ptr)
++{
++    while (q_atomic_swp(&q_atomic_lock, ~0) != 0) ;
++    int originalValue = *ptr;
++    *ptr = originalValue - 1;
++    q_atomic_swp(&q_atomic_lock, 0);
++    return originalValue != 1;
++}
++
++inline int q_atomic_set_int(volatile int *ptr, int newval)
++{
++    while (q_atomic_swp(&q_atomic_lock, ~0) != 0) ;
++    int originalValue = *ptr;
++    *ptr = newval;
++    q_atomic_swp(&q_atomic_lock, 0);
++    return originalValue;
++}
++
++inline void *q_atomic_set_ptr(volatile void *ptr, void *newval)
++{
++    while (q_atomic_swp(&q_atomic_lock, ~0) != 0) ;
++    void *originalValue = *reinterpret_cast<void * volatile *>(ptr);
++    *reinterpret_cast<void * volatile *>(ptr) = newval;
++    q_atomic_swp(&q_atomic_lock, 0);
++    return originalValue;
++}
++
++QT_END_HEADER
++
++#endif // AVR32_QATOMIC_H
+diff -Nupr a/src/corelib/io/qfilesystemwatcher_inotify.cpp b/src/corelib/io/qfilesystemwatcher_inotify.cpp
+--- a/src/corelib/io/qfilesystemwatcher_inotify.cpp	2006-06-30 09:49:45.000000000 +0200
++++ b/src/corelib/io/qfilesystemwatcher_inotify.cpp	2006-07-27 13:24:27.000000000 +0200
+@@ -72,6 +72,10 @@
+ # define __NR_inotify_init      316
+ # define __NR_inotify_add_watch 317
+ # define __NR_inotify_rm_watch  318
++#elif defined (__avr32__)
++# define __NR_inotify_init      240
++# define __NR_inotify_add_watch 241
++# define __NR_inotify_rm_watch  242
+ #elif defined (__SH4__)
+ # define __NR_inotify_init      290
+ # define __NR_inotify_add_watch 291
+diff -uprN a/mkspecs/qws/linux-avr32-g++/qmake.conf b/mkspecs/qws/linux-avr32-g++/qmake.conf
+--- a/mkspecs/qws/linux-avr32-g++/qmake.conf	1970-01-01 01:00:00.000000000 +0100
++++ b/mkspecs/qws/linux-avr32-g++/qmake.conf	2006-08-01 08:47:12.000000000 +0200
+@@ -0,0 +1,85 @@
++#
++# qmake configuration for linux-g++ using the avr32-linux-g++ crosscompiler
++#
++
++MAKEFILE_GENERATOR	= UNIX
++TEMPLATE		= app
++CONFIG			+= qt warn_on release link_prl
++QT                      += core gui network
++QMAKE_INCREMENTAL_STYLE = sublib
++
++QMAKE_CC		= avr32-linux-gcc
++QMAKE_LEX		= flex
++QMAKE_LEXFLAGS		=
++QMAKE_YACC		= yacc
++QMAKE_YACCFLAGS		= -d
++QMAKE_CFLAGS		= -pipe
++QMAKE_CFLAGS_WARN_ON	= -Wall -W
++QMAKE_CFLAGS_WARN_OFF	=
++QMAKE_CFLAGS_RELEASE	= -O2
++QMAKE_CFLAGS_DEBUG	= -g -O2
++QMAKE_CFLAGS_SHLIB	= -fPIC
++QMAKE_CFLAGS_YACC	= -Wno-unused -Wno-parentheses
++QMAKE_CFLAGS_THREAD	= -D_REENTRANT
++QMAKE_CFLAGS_HIDESYMS   = -fvisibility=hidden
++
++QMAKE_CXX		= avr32-linux-g++
++QMAKE_CXXFLAGS		= $$QMAKE_CFLAGS -fno-exceptions
++QMAKE_CXXFLAGS_WARN_ON	= $$QMAKE_CFLAGS_WARN_ON
++QMAKE_CXXFLAGS_WARN_OFF	= $$QMAKE_CFLAGS_WARN_OFF
++QMAKE_CXXFLAGS_RELEASE	= $$QMAKE_CFLAGS_RELEASE
++QMAKE_CXXFLAGS_DEBUG	= $$QMAKE_CFLAGS_DEBUG
++QMAKE_CXXFLAGS_SHLIB	= $$QMAKE_CFLAGS_SHLIB
++QMAKE_CXXFLAGS_YACC	= $$QMAKE_CFLAGS_YACC
++QMAKE_CXXFLAGS_THREAD	= $$QMAKE_CFLAGS_THREAD
++QMAKE_CXXFLAGS_HIDESYMS = $$QMAKE_CFLAGS_HIDESYMS -fvisibility-inlines-hidden
++
++QMAKE_INCDIR		=
++QMAKE_LIBDIR		=
++QMAKE_INCDIR_X11	=
++QMAKE_LIBDIR_X11	=
++QMAKE_INCDIR_QT		= $$[QT_INSTALL_HEADERS]
++QMAKE_LIBDIR_QT		= $$[QT_INSTALL_LIBS]
++QMAKE_INCDIR_OPENGL	=
++QMAKE_LIBDIR_OPENGL	=
++QMAKE_INCDIR_QTOPIA	= $(QPEDIR)/include
++QMAKE_LIBDIR_QTOPIA	= $(QPEDIR)/lib
++
++QMAKE_LINK		= avr32-linux-g++
++QMAKE_LINK_SHLIB	= avr32-linux-g++
++QMAKE_LFLAGS		=
++QMAKE_LFLAGS_RELEASE	=
++QMAKE_LFLAGS_DEBUG	=
++QMAKE_LFLAGS_SHLIB      = -shared
++QMAKE_LFLAGS_PLUGIN     = $$QMAKE_LFLAGS_SHLIB
++QMAKE_LFLAGS_SONAME     = -Wl,-soname,
++QMAKE_LFLAGS_THREAD     =
++QMAKE_RPATH             = -Wl,-rpath,
++
++QMAKE_LIBS		=
++QMAKE_LIBS_DYNLOAD      = -ldl
++QMAKE_LIBS_X11		=
++QMAKE_LIBS_X11SM	=
++QMAKE_LIBS_QT		= -lqte
++QMAKE_LIBS_QT_THREAD    = -lqte-mt
++QMAKE_LIBS_QT_OPENGL	= -lqgl
++QMAKE_LIBS_QTOPIA	= -lqpe -lqtopia
++QMAKE_LIBS_THREAD       = -lpthread
++
++QMAKE_MOC		= $$[QT_INSTALL_BINS]/moc
++QMAKE_UIC		= $$[QT_INSTALL_BINS]/uic
++
++QMAKE_AR		= avr32-linux-ar cqs
++QMAKE_RANLIB		= avr32-linux-ranlib
++
++QMAKE_TAR		= tar -cf
++QMAKE_GZIP		= gzip -9f
++
++QMAKE_COPY		= cp -f
++QMAKE_MOVE		= mv -f
++QMAKE_DEL_FILE		= rm -f
++QMAKE_DEL_DIR		= rmdir
++QMAKE_STRIP             = avr32-linux-strip
++QMAKE_CHK_DIR_EXISTS	= test -d
++QMAKE_MKDIR		= mkdir -p
++load(qt_config)
+diff -uprN a/mkspecs/qws/linux-avr32-g++/qplatformdefs.h b/mkspecs/qws/linux-avr32-g++/qplatformdefs.h
+--- a/mkspecs/qws/linux-avr32-g++/qplatformdefs.h	1970-01-01 01:00:00.000000000 +0100
++++ b/mkspecs/qws/linux-avr32-g++/qplatformdefs.h	2006-07-26 09:16:52.000000000 +0200
+@@ -0,0 +1,22 @@
++/****************************************************************************
++**
++** Copyright (C) 1992-2006 Trolltech ASA. All rights reserved.
++**
++** This file is part of the qmake spec of the Qt Toolkit.
++**
++** Licensees holding valid Qt Preview licenses may use this file in
++** accordance with the Qt Preview License Agreement provided with the
++** Software.
++**
++** See http://www.trolltech.com/pricing.html or email sales@trolltech.com for
++** information about Qt Commercial License Agreements.
++**
++** Contact info@trolltech.com if any conditions of this licensing are
++** not clear to you.
++**
++** This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
++** WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
++**
++****************************************************************************/
++
++#include "../../linux-g++/qplatformdefs.h"