spaces.c

/* spaces.c — single-file allocator with region heaps.
 *
 * Copyright (c) 2021-2026 Praveen Vaddadi <thynktank@gmail.com>
 * Released under the MIT License.  See LICENSE for details.
 */

#define _GNU_SOURCE
#include <limits.h>
#include <stddef.h>
#include <stdint.h>
#include <stdlib.h>
#include <string.h>
#include <stdio.h>
#include <unistd.h>
#include <errno.h>
#include <signal.h>
#include <sys/time.h>
#include <sys/types.h>
#include <sys/mman.h>
#include <sys/ipc.h>
#include <sys/shm.h>
#include <sys/sem.h>
#include <sys/sysinfo.h>
#include <fcntl.h>
#include <malloc.h>
#include <pthread.h>
#include <setjmp.h>
#include <ctype.h>

#pragma GCC diagnostic ignored "-Wcast-function-type"
#pragma GCC diagnostic ignored "-Wpointer-to-int-cast"

int spaces__test_and_clear(volatile long *p)
{
    return __sync_val_compare_and_swap(p, 1, 0);
};

long spaces__InterlockedExchange(volatile long *p, long q)
{
    long old;
    do {
        old = *p;
    } while (__sync_val_compare_and_swap(p, old, q) != old);
    return old;
};

void *spaces__InterlockedCompareExchange(void *volatile *p, void *q, void *r)
{
    return (void *) __sync_val_compare_and_swap(p, r, q);
};

long spaces__InterlockedAdd(volatile long *p, long value)
{
    return __sync_add_and_fetch(p, value);
};

long spaces__InterlockedIncrement(volatile long *p)
{
    return __sync_add_and_fetch(p, 1);
};

long spaces__InterlockedDecrement(volatile long *p)
{
    return __sync_sub_and_fetch(p, 1);
};

int spaces__LogicalProcessorsPerPackage(void)
{

    unsigned int eax, ebx, ecx, edx;
    __asm__ volatile ("cpuid":"=a" (eax), "=b"(ebx), "=c"(ecx), "=d"(edx):"a"(0));
    if (ebx != 0x756e6547u || edx != 0x49656e69u || ecx != 0x6c65746eu)
        return 1;
    __asm__ volatile ("cpuid":"=a" (eax), "=b"(ebx), "=c"(ecx), "=d"(edx):"a"(1));
    {
        unsigned int family = (eax & 0x00000F00u);
        unsigned int ext_family = (eax & 0x00F00000u);
        if (family != 0x00000F00u && ext_family == 0)
            return 1;
        if (!(edx & 0x10000000u))
            return 1;
    }
    __asm__ volatile ("cpuid":"=a" (eax), "=b"(ebx), "=c"(ecx), "=d"(edx):"a"(1));
    return (int) ((ebx >> 16) & 0xFFu);

};

typedef unsigned long SpacesThreadId;


typedef unsigned SpacesVersion;
typedef struct _Chunk *SpacesChunk;

typedef enum {
    SPACES_OK = 0,
    SPACES_ERR_INTERNAL,
    SPACES_ERR_OUT_OF_MEMORY,
    SPACES_ERR_BLOCK_TOO_BIG,
    SPACES_ERR_ALLOC_ZERO,
    SPACES_ERR_RESIZE_FAILED,
    SPACES_ERR_LOCK,
    SPACES_ERR_EXCEEDED_CEILING,
    SPACES_ERR_TOO_MANY_PAGES,
    SPACES_ERR_TOO_MANY_TASKS,
    SPACES_ERR_BAD_CHUNK,
    SPACES_ERR_BAD_BLOCK,
    SPACES_ERR_BAD_FREE_BLOCK,
    SPACES_ERR_BAD_POINTER,
    SPACES_ERR_WRONG_TASK,
    SPACES_ERR_NOT_FIXED_SIZE,
    SPACES_ERR_BAD_FLAGS,
    SPACES_ERR_UNSUPPORTED,
    SPACES_ERR_EXCEEDED_HEAP_LIMIT,
    SPACES_ERR_LICENSE,
    SPACES_ERR_BAD_ALIGNMENT,
    SPACES_ERR_CODE_COUNT,
    MERRORCODEINT_MAX = 0x7fffffff
} SpacesErrorCode;

typedef struct _MERRORINFO {
    SpacesErrorCode errorCode;
    SpacesChunk chunk;

    SpacesChunk argChunk;
    void *argPtr;
    void *argBuf;

    size_t argSize;
    size_t argCount;
    unsigned argFlags;

    const char *file;
    int line;

    unsigned long allocCount;
    unsigned long passCount;
    unsigned checkpoint;

    void *errorAlloc;
    void *corruptAddr;
    struct _MERRORINFO *objectCreationInfo;

    SpacesThreadId threadID;
    unsigned long pid;

    void *callStack[32];
} SpacesErrorInfo;

typedef int (*SpacesErrorFn)
 (SpacesErrorInfo *);

typedef enum {
    SPACES_BLOCK_FIXED = 0x0001u,
    SPACES_BLOCK_VAR_MOVEABLE = 0x0002u,
    SPACES_BLOCK_VAR_FIXED = 0x0004u,
    SPACES_BLOCK_EXTERNAL = 0x0008u,
    SPACES_BLOCK_FREE = 0x0010u,
    MBLOCKTYPEINT_MAX = 0x7fffffff
} SpacesBlockType;

typedef enum {
    SPACES_SMALL_NONE,
    SPACES_SMALL_V3,
    SPACES_SMALL_V5,
    MSMALLBLOCKINT_MAX = 0x7fffffff
} SpacesSmallAllocator;

typedef struct {
    void *entry;
    SpacesChunk chunk;
    SpacesBlockType type;
    int isInUse;
    size_t size;
    unsigned lockCount;
    void *reserved_ptr;
    SpacesChunk reserved_chunk;
} SpacesChunkEntry;

typedef enum {
    SPACES_CHUNK_OK = 1,
    SPACES_CHUNK_CORRUPT = -1,
    SPACES_CHUNK_CORRUPT_FATAL = -2,
    SPACES_CHUNK_END = 0,
    MCHUNKSTATUSINT_MAX = 0x7fffffff
} SpacesChunkStatus;

typedef enum {
    SPACES_PTR_OK = 1,
    SPACES_PTR_WILD = 0,
    SPACES_PTR_FREE = -1,
    MPOINTERSTATUSINT_MAX = 0x7fffffff
} SpacesPointerStatus;

typedef struct {
    SpacesChunk chunk;
    SpacesBlockType type;
    unsigned short blockSizeFS;
    unsigned short smallBlockSize;
    unsigned pageSize;
    size_t floor;
    size_t ceiling;
    unsigned flags;
    SpacesErrorFn errorFn;
} SpacesChunkInfo;

typedef struct {
    size_t growIncrement;
    size_t freeBytes;
    size_t largeBlockThreshold;
    size_t heapLimit;
    size_t heapTotal;
    size_t totalFree;
    int useMunmap;
    int coelesceSystemAllocs;
} SpacesProcessInfo;

typedef enum {
    SPACES_THREAD_EXCLUSIVE_OFF = 0,
    SPACES_THREAD_EXCLUSIVE_ON = 0x10000u,
    SPACES_FREE_ON_THREAD_TERM = 0x20000u
} SpacesThreadExclusive;
extern unsigned short spaces_default_block_size;
extern unsigned spaces_default_page_size;
extern unsigned spaces_default_flags;

extern int spaces_malloc_linked;
extern SpacesChunk spaces_default_chunk;

SpacesChunk spaces_init_default_chunk(void);
int spaces_free_default_chunk(void);
SpacesVersion spaces_version(void);

int spaces_init();
int spaces_shutdown();

int spaces_process_info(SpacesProcessInfo * info);
size_t spaces_process_set_grow_increment(size_t size);
size_t spaces_process_set_free_bytes(size_t size);
size_t spaces_process_set_large_threshold(size_t size);
size_t spaces_process_set_heap_limit(size_t size);
int spaces_process_use_munmap(int bMunmap);
int spaces_process_coalesce_allocs(int bValue);
void spaces_process_flush_all(void);
void spaces_process_disable_fork_handlers(void);
size_t spaces_process_set_page_cache_size(int pageMultiple, size_t size);

SpacesChunk spaces_chunk_create(unsigned flags);
SpacesChunk spaces_chunk_create_fixed(unsigned short sizeFS, size_t, unsigned flags);
SpacesChunk spaces_chunk_create_area(void *addr, size_t size, unsigned);
SpacesChunk spaces_chunk_create_area_ex(void *addr, size_t size, unsigned flags, void *security);
SpacesChunk spaces_chunk_create_shared(const char *, size_t size, unsigned);
SpacesChunk spaces_chunk_attach_shared(SpacesChunk, const char *);
int spaces_chunk_destroy(SpacesChunk);
unsigned spaces_chunk_set_page_size(SpacesChunk, unsigned);

unsigned spaces_chunk_set_max_suballoc(SpacesChunk, unsigned);
int spaces_chunk_set_page_resizing(SpacesChunk, int);

int spaces_chunk_set_block_size(SpacesChunk, unsigned short);

size_t spaces_chunk_set_grow_increment(SpacesChunk, size_t);
size_t spaces_chunk_set_free_bytes(SpacesChunk, size_t);
int spaces_chunk_set_small_allocator(SpacesChunk, SpacesSmallAllocator);

int spaces_chunk_set_max_subchunks(SpacesChunk, unsigned);
int spaces_chunk_set_serialization(SpacesChunk, int);
int spaces_default_chunk_thread_exclusive(unsigned flags);

int spaces_chunk_set_small_block_size(SpacesChunk, unsigned short);
size_t spaces_chunk_set_floor(SpacesChunk, size_t);
size_t spaces_chunk_set_ceiling(SpacesChunk, size_t);
size_t spaces_chunk_preallocate(SpacesChunk, size_t, SpacesBlockType);
size_t spaces_chunk_shrink(SpacesChunk);
size_t spaces_chunk_size(SpacesChunk);
size_t spaces_chunk_count(SpacesChunk);
int spaces_chunk_info(SpacesChunk, void *, SpacesChunkInfo *);
SpacesChunkStatus spaces_chunk_first(SpacesChunkInfo *, int);
SpacesChunkStatus spaces_chunk_next(SpacesChunkInfo *, int);
SpacesChunkStatus spaces_chunk_walk(SpacesChunk, SpacesChunkEntry *);
int spaces_chunk_check(SpacesChunk);
int spaces_chunk_lock(SpacesChunk);
int spaces_chunk_unlock(SpacesChunk);

void *spaces_chunk_alloc(SpacesChunk, size_t, unsigned);
void *spaces_chunk_realloc(void *, size_t, unsigned);
int spaces_chunk_free(void *);
size_t spaces_chunk_ptr_size(void *);
SpacesPointerStatus spaces_chunk_ptr_check(SpacesChunk, void *);

void *spaces_chunk_alloc_aligned(SpacesChunk, size_t, size_t, unsigned);
void *spaces_chunk_alloc_aligned_offset(SpacesChunk, size_t, size_t, size_t, unsigned);
void *spaces_chunk_realloc_aligned(void *, size_t, size_t, unsigned);
void *spaces_chunk_realloc_aligned_offset(void *, size_t, size_t, size_t, unsigned);
int spaces_chunk_free_aligned(void *);
size_t spaces_chunk_size_aligned(void *);
SpacesPointerStatus spaces_chunk_check_aligned(SpacesChunk chunk, void *ptr);

void *spaces_chunk_alloc_fixed(SpacesChunk);
int spaces_chunk_free_fixed(void *);

SpacesErrorFn spaces_set_error_handler(SpacesErrorFn);
int spaces_default_error_handler(SpacesErrorInfo *);
void spaces_error_unwind(void);

int _spaces__enterCriticalSection(void);
void _spaces__leaveCriticalSection(void);
int spaces__call_new_handler_msc(size_t, int);
int spaces__call_malloc_new_handler_msc(void);
typedef int Bool;
typedef int SPACESISBRKINT;

void *spaces__sbrk(size_t size);
extern int MMaxSharedChunks;

void _spaces__delNextChunk(SpacesChunk chunk);
Bool _spaces__initSharedSem(SpacesChunk chunk);
Bool _spaces__lockSharedSem(SpacesChunk chunk);
void _spaces__unlockSharedSem(SpacesChunk chunk);
extern Bool spaces__preForkLock;
extern Bool spaces__preInitThreads;
void spaces__suspendThread(SpacesChunk);
void spaces__resumeThread(SpacesChunk);

int spaces__test_and_clear(volatile long *);

long spaces__InterlockedExchange(volatile long *p, long q);
void *spaces__InterlockedCompareExchange(void *volatile *p, void *q, void *r);

long spaces__InterlockedAdd(volatile long *p, long value);

long spaces__InterlockedIncrement(volatile long *p);
long spaces__InterlockedDecrement(volatile long *p);
typedef unsigned long ThreadID;
typedef pthread_t SpacesiThread;
typedef pthread_once_t Spacesi_Sys_Once;
typedef void Spacesi_Sys_Once_Ret;

typedef pthread_mutex_t Spacesi_Sys_Mutex;
typedef struct {
    Spacesi_Sys_Once once;
     Spacesi_Sys_Once_Ret(*initFn) (void);
    Spacesi_Sys_Mutex m;
    Bool bInit;
    int count;
    ThreadID owner;
    ThreadID prelocked;
} Spacesi_Mutex;

extern Spacesi_Mutex spaces__mutexGlobal;
extern Spacesi_Mutex spaces__mutexMov;
extern Spacesi_Mutex spaces__mutexSMP;
Bool spaces__pthread_initialized(void);

Bool spaces__createAndEnterMutex(Spacesi_Mutex * mutex);
Bool spaces__initMutex(Spacesi_Mutex * mutex);

Bool spaces__mutex_trylock(Spacesi_Mutex * mutex);
typedef struct _ThreadLocalChunk {
    struct _Chunk *chunk;
    ThreadID tid;
} ThreadLocalChunk;

extern ThreadLocalChunk spaces__threadLocalChunks[997];
typedef ThreadID ThreadHandle;
extern Bool spaces__bSMP;
extern int spaces__LogicalProcessorsPerPackage(void);
Bool spaces__initThreadLocalChunk(void);
Bool spaces__setThreadLocalChunk(SpacesChunk, int);
void spaces__insertSubChunk(struct _Chunk *chunk, struct _Chunk *parent, struct _Chunk **pChunk);

typedef struct _PageCacheEntry {
    struct _PageCacheEntry *next;
} PageCacheEntry;

typedef struct _PageCache {

    PageCacheEntry *stack;
    __attribute__((aligned(4))) volatile long lock;
    int count;

    __attribute__((aligned(4))) volatile int inUse;
    int target;
    int init;
    int min;
    int max;

    unsigned char cachePad[64 - sizeof( __attribute__((aligned(4))) volatile long) - sizeof(void *) - sizeof(int) * 6];

} PageCache;

struct _Page *spaces__sysAllocPageCached(struct _Chunk *chunk, size_t size, unsigned flags);
Bool spaces__sysFreePageCached(struct _Page *page);

extern Bool spaces__termPageCache(void);

extern pthread_cond_t spaces__eventPageCache;
extern void *ptr_spacesi_eventPageCache;
extern Bool spaces__createEventPageCache(void);
extern Bool spaces__deleteEventPageCache(void);
extern Bool spaces__signalEventPageCache(void);
extern Bool spaces__waitForEventPageCache(void);
typedef long MSIGNEDSIZET;
typedef unsigned long PageSize;
typedef unsigned short PageType;
typedef struct _Block {
    PageSize sizeAndTags;

} Block;

typedef struct _FreeBlock {
    PageSize sizeAndTags;

    struct _FreeBlock *next;
    struct _FreeBlock *prev;
} FreeBlock;

typedef struct _FreeSmallBlock {
    struct _FreeSmallBlock *next;
} FreeSmallBlock;

typedef union {
    struct _Page *page;
    FreeSmallBlock *block;
} SmallFreeList;
typedef union _FSBlock {

    union _FSBlock *next;
} FSBlock;
typedef struct _Page {
    struct _Chunk *chunk;
    struct _PageHeader *pageHeader;

    size_t cache_buf[2];

    PageSize allocCount;
    PageType flagsAndSignature;

    union {
        struct {
            FreeBlock *rover;
            FreeBlock *freeList;
            PageSize minBlockSize;
        } var;
        struct {
            FSBlock *freeList;
            char *end;
            char *free;
            struct _Page *prev;
            struct _Page *next;
            SmallFreeList *head;
            unsigned index;
        } fs;
        struct {

            unsigned long alignment;

            unsigned type;
        } ext;

    } hdr;
} Page;

typedef struct _PageHeader {
    PageSize largestFree;

    PageSize moveableFlags;
    Page *page;
    struct _PageHeader *next;
    struct _PageHeader *prev;
} PageHeader;

typedef struct _PageHdrStorage {
    struct _PageHdrStorage *next;
    struct _PageHeader pages[1];
} PageHdrStorage;
extern unsigned long spaces__pageSize;
extern Bool spaces__munmapEnabled;

unsigned long spaces__sysGetPageSize(void);

typedef struct _FreeArea {
    struct _Area *area;
    struct _FreeArea *next;
    struct _FreeArea *prev;
    size_t size;

} FreeArea;

typedef FreeArea TailArea;

typedef struct _Area {
    union {
        FreeArea *freeArea;
        size_t inUseSize;
    } sizeOrFree;
    TailArea *tailArea;
    size_t commitSize;
    size_t prevFreeSize;

} Area;
typedef struct _Chunk {
    struct _Chunk *smpParent;
    unsigned flags;
    unsigned signature;
    size_t cache_pad1[2];

    struct _smpQueue volatile *smpFreeQueue;
    __attribute__((aligned(4))) volatile long lock;
    ThreadID locktid;
    SpacesSmallAllocator allocSmallFn;
    unsigned smallSize;

    unsigned cache_pad2[1];
    SmallFreeList
        smallFreeLists[((((((2048 +
                             ((PageSize)
                              ((PageSize) ((PageSize) (0) + (PageSize) ((sizeof(double)) - 1u)) &
                               ((PageSize) (~((PageSize) ((sizeof(double)) - 1u)))))) - 0) >> 3) + 1)) >
                         ((((2048 +
                             ((PageSize)
                              ((PageSize) ((PageSize) (0) + (PageSize) ((sizeof(double)) - 1u)) &
                               ((PageSize) (~((PageSize) ((sizeof(double)) - 1u)))))) - 0) >> 3) + 1))) ? ((((2048 +
                                                                                                              ((PageSize) ((PageSize) ((PageSize) (0) + (PageSize) ((sizeof(double)) - 1u)) & ((PageSize) (~((PageSize) ((sizeof(double)) - 1u)))))) - 0) >> 3) + 1)) : ((((2048 + ((PageSize) ((PageSize) ((PageSize) (0) + (PageSize) ((sizeof(double)) - 1u)) & ((PageSize) (~((PageSize) ((sizeof(double)) - 1u)))))) - 0) >> 3) + 1)))];
    size_t growIncrement;
    size_t cache_pad3[2];

    PageHeader *rovers[((PageType) 7)];
    PageHeader *freePages;

    PageSize pageSize;
    PageSize maxSubAlloc;
    PageSize minPageSize;
    size_t freeBytes;
    size_t totalFree;
    size_t pageTotal;
    size_t floor;
    size_t ceiling;

    struct _AreaChunk *areaChunk;
    size_t totalSize;
    size_t committedSize;
    FreeArea *freeFreeAreas;
    FreeArea *freeAreas;
    FreeArea freeAreaSentinel;
    TailArea *tailAreas;
    TailArea tailAreaSentinel;

     PageSize(*compactChunkFn) (struct _Chunk *, PageSize);
     PageSize(*compactPageFn) (Page *, PageSize, FreeBlock *);

    int subChunkCount;
    int maxSubChunks;
    int subChunkSharing;
    ThreadID smpThreadID;
    struct _Chunk **subChunkPosition;
    int subChunkLimit;
    struct _Chunk *smpNextChunk;
    struct _Chunk *subChunks[257];

    union {
        struct {
            struct _Chunk *next;
            struct _TaskRecord *taskRec;
        } private_;
        struct {
            int sharedRefCount;
            int shmid;
            int semid;
            ThreadID threadID;
        } shared;
    } task;
    Spacesi_Mutex mutex;
    size_t savedFreeBytes;
    unsigned short blockSizeFS;
    unsigned short pageResizing;
    struct _Chunk *nextFree;

    PageHdrStorage *extraPages;

    PageHeader pages[1];
} Chunk;

typedef struct _AreaChunk {
    Area area;
    Chunk chunk;
} AreaChunk;
typedef struct {
    ThreadID id;
    int handlingError;

} ThreadContext;

typedef struct _TaskRecord {

    SpacesErrorFn errorFn;
    SpacesChunk chunks;
    unsigned regCount;
    unsigned allocFlags;

    ThreadContext threadContexts[25];
    unsigned threadContextCount;

} TaskRecord;
typedef struct {
    SpacesErrorCode code;
    const char msg[32];
} SpacesiErrorMessage;

Bool _spaces__invokeErrorHandler1(SpacesChunk, SpacesErrorCode);
Bool _spaces__sysReportError(const char *msg, Bool bRecoverable, TaskRecord * taskRec, SpacesErrorInfo * info);
typedef void (*VoidFn)();
Bool _spaces__sysValidateFunction(VoidFn);
Bool _spaces__sysValidatePtr(void *ptr, size_t len, unsigned flags);
int _spaces__isBlockInUseFS(Page *, Chunk *, FSBlock *);
int spaces__isBlockInUseSmall(Chunk * chunk, FreeSmallBlock * block);
void *spaces__sysGetM(Chunk * chunk, void *addr, size_t minSize, size_t *size, unsigned flags);
Bool spaces__sysReturnM(Chunk * chunk, void *addr64, size_t *size64, unsigned flags, Bool bResize);
Bool spaces__sysResizeM(Chunk * chunk, void *addr, size_t oldSize, size_t *size,
                        size_t oldSize64, size_t *size64, unsigned flags);
void *spaces__sysCommitM(void *addr, size_t size);
Bool spaces__sysDecommitM(void *addr, size_t size);
Bool spaces__sysFreeAddressSpace(void *addr, size_t size, Bool bResize, size_t *released);

void *_spaces__sysAlloc(size_t, unsigned);
Bool _spaces__sysFree(void *);
void *_spaces__sysRealloc(void *, size_t, unsigned);
size_t _spaces__sysSize(void *);

Bool _spaces__sysResize(void *, size_t, unsigned);

void _spaces__taskRemoveChunk(Chunk *);
void _spaces__expungeTaskRec(TaskRecord *, Bool);
Bool _spaces__AnyChunks(void);

void *_spaces__sysAllocNear(unsigned);
void *_spaces__sysReAllocNear(void *, unsigned);
void _spaces__sysFreeNear(void *);
extern TaskRecord _spaces__TaskRecord;
typedef SpacesChunk ThreadChunk;

ThreadID _spaces__getCurrentThreadID(void);
SpacesiThread spaces__getCurrentThread(void);
ThreadContext *_spaces__getCurrentThreadContext(TaskRecord * taskRec, Bool bInsert);
void _spaces__deleteThreadContext(TaskRecord *, ThreadContext *);

typedef struct _smpQueue {
    struct _smpQueue volatile *next;

} SmpQueue;

Bool spaces__smpEnqueueFree(ThreadChunk p, void *ptr);
void spaces__smpFlushQueue(ThreadChunk p);
Bool spaces__runThread(void (*fn)(void *), void *arg, ThreadHandle * result);

void spaces__freeThreadExcChunk(SpacesChunk, SpacesThreadId);

Chunk *spaces__initSubChunk(SpacesChunk parent, unsigned flags);
int spaces__getProcessorCount(void);
ThreadChunk spaces__getProcessorChunk(ThreadChunk parent);
Bool spaces__smpInitChunk(SpacesChunk chunk);
void spaces__smpYield(unsigned count);

typedef void (*FREEFN) (void *, Bool *);

extern FREEFN _spaces__freeFns[((PageType) 7)];

unsigned long _spaces__getCurrentProcessID(void);
SpacesChunk *_spaces__getNextChunk(SpacesChunk);
SpacesChunk _spaces__sysAllocNamedShared(size_t size, size_t totalSize,
                                         unsigned flags, void *addr,
                                         unsigned pidCount, unsigned long *pids, void *security, const char *name);
Bool spaces__initSharedChunk(SpacesChunk chunk, unsigned flags, void *security);
extern PageSize(*_spaces__compactChunkFn) (struct _Chunk *, PageSize);
extern PageSize(*_spaces__compactPageFn) (Page *, PageSize, FreeBlock *);
extern size_t spaces__sysHeapTotal;
void spaces__initializeAreaChunk(AreaChunk * areaChunk, size_t totalSize, size_t size);
SpacesChunk _spaces__registerShared(SpacesChunk, const char *, Bool, Bool *);
int _spaces__unregisterShared(SpacesChunk, Bool);
void *_spaces__sysAllocChunk(SpacesChunk, size_t, unsigned);
void *_spaces__sysReallocChunk(SpacesChunk, void *, size_t, unsigned);
Bool _spaces__sysResizeChunk(SpacesChunk, void *, size_t, unsigned);
size_t _spaces__sysSize(void *mem);
Bool _spaces__sysFreeChunk(SpacesChunk, void *);
Bool spaces__sysFreeChunk1(SpacesChunk, void *, Bool);

SpacesChunk spaces__sysAllocArea(size_t size, size_t totalSize, unsigned flags, void *addr, void *security);

extern SpacesChunk _spaces__chunkTerminating;
extern size_t spaces__defaultChunkFloor;
extern size_t spaces__defaultChunkGrowIncrement;
PageHeader *spaces__allocPageHeader(Chunk *);
void spaces__freePageHeader(Chunk *, PageHeader *);
Bool _spaces__chunkFree(Chunk * chunk, Bool bTerminating);
size_t _spaces__chunkCount(Chunk * chunk);
Bool spaces__chunkCheck(SpacesChunk chunk);
size_t spaces__memSizePtr(void *mem);
size_t spaces__memSizePtrRaw(void *mem, Bool bRaw);

Bool spaces__initFreePage(Chunk * chunk, Page * page);
Page *spaces__shrinkOnePage(Chunk * chunk);
size_t spaces__preallocBytes(Chunk * chunk, PageType type, size_t bytes);
void spaces__adjustThreshold(size_t *threshold, size_t def, size_t cmp, unsigned pwr);

Bool _spaces__initPageHeaders(Chunk *);
PageSize _spaces__initPageVariable(Page *, PageSize);
void *_spaces__allocBlock(Page * page, PageSize size, unsigned flags);
Bool _spaces__resizeVar(Block *, PageSize);

void *_spaces__allocVar(Chunk *, unsigned, PageSize);
void _spaces__freeVar(void *, Bool * pageDeleted);
PageSize _spaces__resizeAny(void **, void *, size_t, unsigned);
void *_spaces__allocExternal(Chunk *, unsigned, size_t);
Bool spaces__deletePage(Page *, Bool);
void _spaces__removeFromFreeList(FreeBlock *);
void _spaces__insertIntoFreeList(FreeBlock *, FreeBlock *);

extern int spaces__bitcount(size_t val);

SpacesChunkStatus _spaces__walkChunk(Chunk *, SpacesChunkEntry *, Bool, Bool);

SpacesChunkStatus spaces__checkChunkPage(SpacesChunkEntry * entry);
void _spaces__removeFromFreeList(FreeBlock * block)
{
    {
        (block)->prev->next = (block)->next;
        (block)->next->prev = (block)->prev;
    };
};

void _spaces__insertIntoFreeList(FreeBlock * block, FreeBlock * freeList)
{

    {
        (block)->prev = (freeList);
        (block)->next = (freeList)->next;
        (freeList)->next->prev = (block);
        (freeList)->next = (block);
    };
    if (((block)->sizeAndTags & ((PageSize) (~3u)))) {

    }
};

typedef volatile int spaces_spinlock_t;

static inline __attribute__((always_inline))
void spaces_spin_lock(spaces_spinlock_t * lock)
{
    while (__sync_lock_test_and_set(lock, 1)) {
        do {
            __asm__ volatile ("pause":::"memory");
        } while (__atomic_load_n(&(*lock), 0));
    }
};

static inline __attribute__((always_inline))
int spaces_spin_trylock(spaces_spinlock_t * lock)
{
    return !__sync_lock_test_and_set(lock, 1);
};

static inline __attribute__((always_inline))
void spaces_spin_unlock(spaces_spinlock_t * lock)
{
    __sync_lock_release(lock);
};

typedef struct {
    volatile uint32_t next;
    volatile uint32_t owner;
} __attribute__((aligned(64))) spaces_ticket_lock_t;

static inline __attribute__((always_inline))
void spaces_ticket_lock(spaces_ticket_lock_t * lock)
{
    uint32_t ticket = __atomic_fetch_add(&(lock->next), (1), 4);
    while (__atomic_load_n(&(lock->owner), 0) != ticket) {
        __asm__ volatile ("pause":::"memory");
    }
};

static inline __attribute__((always_inline))
void spaces_ticket_unlock(spaces_ticket_lock_t * lock)
{
    __atomic_fetch_add(&(lock->owner), (1), 4);
};

typedef struct spaces_mcs_node {
    struct spaces_mcs_node *volatile next;
    volatile char flag;
} __attribute__((aligned(64))) spaces_mcs_node_t;

typedef spaces_mcs_node_t *volatile spaces_mcs_lock_t;

static inline __attribute__((always_inline))
void spaces_mcs_lock(spaces_mcs_lock_t * lock, spaces_mcs_node_t * me)
{
    me->next = 0;
    spaces_mcs_node_t *prev = (spaces_mcs_node_t *) __sync_lock_test_and_set(lock, me);
    if (prev) {
        me->flag = 0;
        prev->next = me;
        while (!me->flag) {
            __asm__ volatile ("pause":::"memory");
        }
    }
};

static inline __attribute__((always_inline))
int spaces_mcs_trylock(spaces_mcs_lock_t * lock, spaces_mcs_node_t * me)
{
    me->next = 0;
    spaces_mcs_node_t *prev = (spaces_mcs_node_t *) __sync_val_compare_and_swap(lock, 0, me);
    return (prev == 0);
};

static inline __attribute__((always_inline))
void spaces_mcs_unlock(spaces_mcs_lock_t * lock, spaces_mcs_node_t * me)
{
    if (me->next == 0) {
        if (me == __sync_val_compare_and_swap(lock, me, 0)) {
            return;
        }
        while (!me->next) {
            __asm__ volatile ("pause":::"memory");
        }
    }
    me->next->flag = 1;
};

typedef struct spaces_lfnode {
    struct spaces_lfnode *next;
} spaces_lfnode_t;

typedef uintptr_t spaces_tagged_ptr_t;

static inline __attribute__((always_inline)) spaces_tagged_ptr_t spaces_tag_ptr(void *ptr, uint16_t tag)
{
    return ((uintptr_t) ptr & ((1ULL << 48) - 1)) | ((uintptr_t) tag << 48);
};

static inline __attribute__((always_inline))
void *spaces_untag_ptr(spaces_tagged_ptr_t tagged)
{

    uintptr_t raw = tagged & ((1ULL << 48) - 1);
    if (raw & (1ULL << 47))
        raw |= ~((1ULL << 48) - 1);
    return (void *) raw;
};

static inline __attribute__((always_inline)) uint16_t spaces_get_tag(spaces_tagged_ptr_t tagged)
{
    return (uint16_t) (tagged >> 48);
};

typedef struct {
    volatile spaces_tagged_ptr_t head;
} __attribute__((aligned(64))) spaces_lfstack_t;

static inline __attribute__((always_inline))
void spaces_lfstack_init(spaces_lfstack_t * s)
{
    s->head = 0;
};

static inline __attribute__((always_inline))
void spaces_lfstack_push(spaces_lfstack_t * s, spaces_lfnode_t * node)
{
    spaces_tagged_ptr_t old_head = __atomic_load_n(&(s->head), 0);
    spaces_tagged_ptr_t new_head;
    do {
        node->next = (spaces_lfnode_t *) spaces_untag_ptr(old_head);
        new_head = spaces_tag_ptr(node, spaces_get_tag(old_head) + 1);
    } while (!__atomic_compare_exchange_n(&(s->head), &(old_head), (new_head), 1, 4, 2));
};

static inline __attribute__((always_inline))
spaces_lfnode_t *spaces_lfstack_pop(spaces_lfstack_t * s)
{
    spaces_tagged_ptr_t old_head = __atomic_load_n(&(s->head), 2);
    spaces_tagged_ptr_t new_head;
    spaces_lfnode_t *node;
    do {
        node = (spaces_lfnode_t *) spaces_untag_ptr(old_head);
        if (!node)
            return 0;
        new_head = spaces_tag_ptr(node->next, spaces_get_tag(old_head) + 1);
    } while (!__atomic_compare_exchange_n(&(s->head), &(old_head), (new_head), 1, 4, 2));
    return node;
};

static inline __attribute__((always_inline))
void spaces_lfstack_push_chain(spaces_lfstack_t * s, spaces_lfnode_t * first, spaces_lfnode_t * last)
{
    spaces_tagged_ptr_t old_head = __atomic_load_n(&(s->head), 0);
    spaces_tagged_ptr_t new_head;
    do {
        last->next = (spaces_lfnode_t *) spaces_untag_ptr(old_head);
        new_head = spaces_tag_ptr(first, spaces_get_tag(old_head) + 1);
    } while (!__atomic_compare_exchange_n(&(s->head), &(old_head), (new_head), 1, 4, 2));
};

static inline __attribute__((always_inline))
spaces_lfnode_t *spaces_lfstack_take_all(spaces_lfstack_t * s)
{
    spaces_tagged_ptr_t old_head = __atomic_exchange_n(&(s->head), ((spaces_tagged_ptr_t) 0), 4);
    return (spaces_lfnode_t *) spaces_untag_ptr(old_head);
};

static inline __attribute__((always_inline))
int spaces_lfstack_empty(spaces_lfstack_t * s)
{
    return spaces_untag_ptr(__atomic_load_n(&(s->head), 0)) == 0;
};

typedef struct {
    uint32_t size;
    uint32_t slab_capacity;
    uint32_t cache_max;
    uint32_t cache_drain;
} spaces_sizeclass_t;
typedef struct spaces_slab {

    uint32_t magic;
    uint8_t size_class;
    uint8_t state;
    uint16_t capacity;
    volatile uint32_t alloc_count;
    uint32_t obj_size;
    spaces_lfnode_t *local_free;
    struct spaces_heap *owner;
    uint32_t bump_offset;
    uint32_t _pad0;

    spaces_lfstack_t remote_free __attribute__((aligned(64)));
    struct spaces_slab *next;
    struct spaces_slab *prev;
    uint32_t remote_free_count;
    uint32_t _pad1;
    size_t mmap_size;
    void *mmap_base;
} spaces_slab_t;
typedef struct {
    spaces_lfnode_t *head;
    int32_t count;
    int32_t _pad;
} spaces_cache_bin_t;

typedef struct spaces_heap {

    spaces_cache_bin_t bins[64];

    spaces_slab_t *active[64];

    spaces_slab_t *partial_slabs[64];
    int heap_id;
    int initialized;
    struct spaces_heap *next_free;
} spaces_heap_t;

typedef struct {
    int initialized;
    int os_page_size;
    int has_hugepages;
    int num_cpus;

    spaces_lfstack_t central_partial[64];
    spaces_lfstack_t empty_slabs;

    spaces_sizeclass_t classes[64];
    int num_classes;

    uint8_t small_class_lookup[(8 * 1024) / 8 + 1];

    spaces_spinlock_t large_lock;
    volatile size_t total_mapped;
    volatile size_t total_active;

    spaces_spinlock_t heap_pool_lock;
    spaces_heap_t *heap_pool_free;
} spaces_global_t;

void spaces_core_init(void);
void *spaces_malloc(size_t size);
void spaces_free(void *ptr);
void *spaces_calloc(size_t nobj, size_t size);
void *spaces_realloc(void *ptr, size_t size);
void *spaces_memalign(size_t alignment, size_t size);
size_t spaces_usable_size(void *ptr);
void spaces_thread_cleanup(void);
void *M_malloc(size_t size);
void *M_calloc(size_t nobj, size_t size);
void *M_realloc(void *p, size_t size);
void M_free(void *p);
unsigned short spaces_default_block_size = (0x7fff * 2 + 1);
unsigned spaces_default_page_size = 0;
unsigned spaces_default_flags = 0x8000u;
SpacesChunk spaces_default_chunk = 0;

SpacesChunk spaces_init_default_chunk()
{
    if (!_spaces__enterCriticalSection())
        return 0;

    if (!spaces_default_chunk) {

        spaces_malloc_linked = 1;

        if ((spaces_default_chunk = spaces_chunk_create(0x8000u | spaces_default_flags)) != 0) {
            if (spaces_default_page_size != 0)
                spaces_chunk_set_page_size(spaces_default_chunk, spaces_default_page_size);
            if (spaces_default_block_size != (0x7fff * 2 + 1)
                )
                spaces_chunk_set_block_size(spaces_default_chunk, spaces_default_block_size);
        }
    }

    _spaces__leaveCriticalSection();

    return spaces_default_chunk;
};

int spaces_free_default_chunk(void)
{
    SpacesChunk chunk;

    if (!_spaces__enterCriticalSection())
        return 0;
    if ((chunk = spaces_default_chunk) != 0)
        spaces_default_chunk = 0;
    _spaces__leaveCriticalSection();

    if (chunk)
        return spaces_chunk_destroy(chunk);

    return 0;
};

Bool _spaces__sysReportError(const char *msg, int recoverable, TaskRecord * taskRec, SpacesErrorInfo * lpErr)
{
    unsigned flags = 0;
    (void)taskRec;
    (void)lpErr;

    {
        if (!(flags & 0x8000u))
            setbuf(stderr, 0);

        fputs(msg, stderr);
    }

    fputc('\a', stderr);

    for (;;) {
        fputc('\n', stderr);
        fputs("Abort, ", stderr);
        if (recoverable)
            fputs("Retry, ", stderr);
        fputs("Ignore? ", stderr);
        switch (getchar()) {
        case 'A':
        case 'a':
            abort();
        case 'I':
        case 'i':
            return 0;
        case 'R':
        case 'r':
            if (recoverable)
                return 1;
            break;
        }
    }

    return 0;
};

static Bool _spaces__detectErrorRecursion(TaskRecord * taskRec, SpacesErrorInfo * lpErr, int nestingAllowed);

static const char *_spaces__getString(SpacesErrorCode);
Bool _spaces__invokeErrorHandler1(SpacesChunk chunk, SpacesErrorCode code)
{
    TaskRecord *taskRec;
    SpacesErrorInfo errorInfo = { 0 };
    Bool result = 0;
    SpacesErrorFn fn;

    memset(&errorInfo, 0, sizeof(SpacesErrorInfo));

    errorInfo.chunk = chunk;
    errorInfo.errorCode = code;

    if ((taskRec = (&_spaces__TaskRecord)) == 0)
        return 0;
    {
        if (!spaces__createAndEnterMutex(&spaces__mutexGlobal))
            return 0;
    };

    if (taskRec->errorFn) {

        if (_spaces__sysValidateFunction((VoidFn) taskRec->errorFn))
            fn = taskRec->errorFn;
        else
            fn = taskRec->errorFn = spaces_default_error_handler;
    } else
        fn = 0;

    {
        if (!spaces__preInitThreads)
            (--(&spaces__mutexGlobal)->count, pthread_mutex_unlock(&(&spaces__mutexGlobal)->m));
    };

    if (!fn)
        return 0;

    {
        {

            {

                if (_spaces__detectErrorRecursion(taskRec, &errorInfo, 0))
                    result = 0;

                else
                    result = (*fn) (&errorInfo);
            }

        }
        {

            spaces_error_unwind();

        }
    }

    return result;
};

static SpacesiErrorMessage spaces__errorMessages[SPACES_ERR_CODE_COUNT] = {
    { SPACES_OK, "" },
    { SPACES_ERR_INTERNAL, "SPACES_ERR_INTERNAL" },
    { SPACES_ERR_OUT_OF_MEMORY, "" },
    { SPACES_ERR_BLOCK_TOO_BIG, "SPACES_ERR_BLOCK_TOO_BIG" },
    { SPACES_ERR_ALLOC_ZERO, "SPACES_ERR_ALLOC_ZERO" },
    { SPACES_ERR_RESIZE_FAILED, "SPACES_ERR_RESIZE_FAILED" },
    { SPACES_ERR_LOCK, "SPACES_ERR_LOCK" },
    { SPACES_ERR_EXCEEDED_CEILING, "SPACES_ERR_EXCEEDED_CEILING" },
    { SPACES_ERR_TOO_MANY_PAGES, "SPACES_ERR_TOO_MANY_PAGES" },
    { SPACES_ERR_TOO_MANY_TASKS, "SPACES_ERR_TOO_MANY_TASKS" },
    { SPACES_ERR_BAD_CHUNK, "SPACES_ERR_BAD_CHUNK" },
    { SPACES_ERR_BAD_BLOCK, "SPACES_ERR_BAD_BLOCK" },
    { SPACES_ERR_BAD_FREE_BLOCK, "SPACES_ERR_BAD_FREE_BLOCK" },
    { SPACES_ERR_BAD_POINTER, "SPACES_ERR_BAD_POINTER" },
    { SPACES_ERR_WRONG_TASK, "SPACES_ERR_WRONG_TASK" },
    { SPACES_ERR_NOT_FIXED_SIZE, "SPACES_ERR_NOT_FIXED_SIZE" },
    { SPACES_ERR_BAD_FLAGS, "SPACES_ERR_BAD_FLAGS" },
    { SPACES_ERR_UNSUPPORTED, "SPACES_ERR_UNSUPPORTED" },
    { SPACES_ERR_EXCEEDED_HEAP_LIMIT, "SPACES_ERR_EXCEEDED_HEAP_LIMIT" },
    { SPACES_ERR_LICENSE, "SPACES_ERR_LICENSE" },
    { SPACES_ERR_BAD_ALIGNMENT, "SPACES_ERR_BAD_ALIGNMENT" }
};

static const char *_spaces__getString(SpacesErrorCode errorCode)
{
    static const char szOutM[] = "Out of memory.  Please free some memory, then choose retry.";
    static const char szLicense[] =
        "Spaces license error: Please contact app vendor, as this app uses a version of the Spaces library that is licensed only for single-process-package hardware; the SMP version of Spaces is required if multiple CPU packages are present at runtime.";

    if (errorCode == SPACES_ERR_OUT_OF_MEMORY)
        return szOutM;
    else if (errorCode == SPACES_ERR_LICENSE) {

        return szLicense;
    } else
        return spaces__errorMessages[errorCode].msg;
};

Bool spaces_default_error_handler(SpacesErrorInfo * err)
{
    SpacesErrorCode errorCode = err->errorCode;
    Bool bRecoverable, bResult;
    const char *errString;
    TaskRecord *taskRec;


    if ((taskRec = (&_spaces__TaskRecord)) == 0)
        return 0;

    switch (errorCode) {

    case SPACES_ERR_OUT_OF_MEMORY:
    case SPACES_ERR_EXCEEDED_HEAP_LIMIT:
        bRecoverable = 1;
        break;

    case SPACES_ERR_BLOCK_TOO_BIG:
    case SPACES_ERR_ALLOC_ZERO:
    case SPACES_ERR_RESIZE_FAILED:
    case SPACES_ERR_LOCK:
    case SPACES_ERR_EXCEEDED_CEILING:
    case SPACES_ERR_TOO_MANY_PAGES:
    case SPACES_ERR_TOO_MANY_TASKS:
    case SPACES_ERR_BAD_CHUNK:
    case SPACES_ERR_BAD_BLOCK:
    case SPACES_ERR_BAD_FREE_BLOCK:
    case SPACES_ERR_BAD_POINTER:
    case SPACES_ERR_NOT_FIXED_SIZE:
    case SPACES_ERR_BAD_FLAGS:
    case SPACES_ERR_UNSUPPORTED:
    case SPACES_ERR_LICENSE:
    case SPACES_ERR_BAD_ALIGNMENT:
        bRecoverable = 0;
        break;

    default:
        bRecoverable = 0;
        errorCode = SPACES_ERR_INTERNAL;
    }

    errString = _spaces__getString(errorCode);
    bResult = _spaces__sysReportError(errString, bRecoverable, taskRec, err);

    return bResult;
};

SpacesErrorFn spaces_set_error_handler(SpacesErrorFn errorFn)
{
    SpacesErrorFn oldErrorFn;
    TaskRecord *taskRec;


    {
        if (!spaces__createAndEnterMutex(&spaces__mutexGlobal))
            return 0;
    };

    taskRec = (&_spaces__TaskRecord);

    if (taskRec && (!errorFn || _spaces__sysValidateFunction((VoidFn) errorFn))) {
        oldErrorFn = taskRec->errorFn;
        taskRec->errorFn = errorFn;
    } else
        oldErrorFn = 0;

    {
        if (!spaces__preInitThreads)
            (--(&spaces__mutexGlobal)->count, pthread_mutex_unlock(&(&spaces__mutexGlobal)->m));
    };

    return oldErrorFn;
};

static Bool _spaces__detectErrorRecursion(TaskRecord * taskRec, SpacesErrorInfo * lpErr, int nestingAllowed)
{
    int nestingActual;

    if (lpErr && lpErr->errorCode == SPACES_ERR_OUT_OF_MEMORY)
        nestingAllowed++;

    {
        ThreadContext *threadContext;

        {
            if (!spaces__createAndEnterMutex(&spaces__mutexGlobal))
                return 0;
        };

        threadContext = _spaces__getCurrentThreadContext(taskRec, 1);

        if (!threadContext) {
            {
                if (!spaces__preInitThreads)
                    (--(&spaces__mutexGlobal)->count, pthread_mutex_unlock(&(&spaces__mutexGlobal)->m));
            };
            _spaces__sysReportError("" "\nMemory errors in too many threads concurrently.\n" "", 0, taskRec, 0);
            return 1;
        }
        nestingActual = threadContext->handlingError++;

        {
            if (!spaces__preInitThreads)
                (--(&spaces__mutexGlobal)->count, pthread_mutex_unlock(&(&spaces__mutexGlobal)->m));
        };
    }
    if (nestingActual == nestingAllowed + 1) {

        _spaces__sysReportError("" "\n" "Spaces" " error handler recursively re-entered.\n" "", 0, taskRec, 0);

    }

    return nestingActual > nestingAllowed;
};

void spaces_error_unwind()
{
    TaskRecord *taskRec;


    if ((taskRec = (&_spaces__TaskRecord)) == 0)
        return;

    {
        if (!spaces__createAndEnterMutex(&spaces__mutexGlobal))
            return;
    };
    {
        ThreadContext *threadContext = _spaces__getCurrentThreadContext(taskRec, 0);

        if (threadContext && --threadContext->handlingError == 0)
            _spaces__deleteThreadContext(taskRec, threadContext);
    }
    {
        if (!spaces__preInitThreads)
            (--(&spaces__mutexGlobal)->count, pthread_mutex_unlock(&(&spaces__mutexGlobal)->m));
    };

};

TaskRecord _spaces__TaskRecord = { spaces_default_error_handler, 0, 0u,

    0u,

    { { 0ul, 0u}
      },

    0u
};

Bool spaces_init()
{
    TaskRecord *taskRec;


    if (!spaces__pthread_initialized())
        return 0;

    {
        if (!spaces__createAndEnterMutex(&spaces__mutexGlobal))
            return 0;
    };

    if (1)
        taskRec = (&_spaces__TaskRecord);
    else
        taskRec = 0;

    if (taskRec) {
        if (taskRec->regCount++ == 0 && taskRec->chunks)
            taskRec->regCount++;
    }

    {
        if (!spaces__preInitThreads)
            (--(&spaces__mutexGlobal)->count, pthread_mutex_unlock(&(&spaces__mutexGlobal)->m));
    };

    return taskRec != 0;
};

Bool spaces_shutdown()
{
    TaskRecord *taskRec;
    Bool bTerminate = 0;



    {
        if (!spaces__createAndEnterMutex(&spaces__mutexGlobal))
            return 0;
    };

    taskRec = (&_spaces__TaskRecord);

    if (taskRec && (taskRec->regCount == 0 || --taskRec->regCount == 0)) {
        _spaces__expungeTaskRec((taskRec), 1);
        bTerminate = 1;
    }

    {
        if (!spaces__preInitThreads)
            (--(&spaces__mutexGlobal)->count, pthread_mutex_unlock(&(&spaces__mutexGlobal)->m));
    };
    if (bTerminate) {
        {
            if (spaces__mutexGlobal.bInit) {
                pthread_mutex_destroy(&spaces__mutexGlobal.m);
                spaces__mutexGlobal.bInit = 0;
            }
            if (spaces__mutexSMP.bInit) {
                pthread_mutex_destroy(&spaces__mutexSMP.m);
                spaces__mutexSMP.bInit = 0;
            }
            if (spaces__mutexMov.bInit) {
                pthread_mutex_destroy(&spaces__mutexMov.m);
                spaces__mutexMov.bInit = 0;
            }
        };
    }

    return taskRec != 0;
};

void _spaces__expungeTaskRec(TaskRecord * taskRec, Bool bStillValid)
{
    if (!bStillValid)
        taskRec->chunks = 0;
    while (taskRec->chunks)
        if ((_spaces__sysValidatePtr(taskRec->chunks, sizeof(Chunk), 0x0002 | 0x0100)
             && ((taskRec->chunks)->signature == 0xBEADu)))
            _spaces__chunkFree(taskRec->chunks, 1);
        else
            taskRec->chunks =
                (* (((taskRec->chunks)->flags & 0x0001u) ? _spaces__getNextChunk(taskRec->chunks) : &((taskRec->chunks)->
                                                                                                    task.private_.
                                                                                                    next)));

};

void _spaces__taskRemoveChunk(Chunk * chunk)
{
    TaskRecord *taskRec;
    Chunk *prevChunk = 0, *p;

    if (chunk->flags & 0x0001u)
        taskRec = (&_spaces__TaskRecord);
    else
        taskRec = chunk->task.private_.taskRec;

    for (p = taskRec->chunks; p;
         prevChunk = p, p = (*(((p)->flags & 0x0001u) ? _spaces__getNextChunk(p) : &((p)->task.private_.next))))
        if (p == chunk) {
            if (prevChunk)
                (* (((prevChunk)->flags & 0x0001u) ? _spaces__getNextChunk(prevChunk) : &((prevChunk)->task.private_.
                                                                                        next))) =
                   (*(((p)->flags & 0x0001u) ? _spaces__getNextChunk(p) : &((p)->task.private_.next)));
            else
                taskRec->chunks = (*(((p)->flags & 0x0001u) ? _spaces__getNextChunk(p) : &((p)->task.private_.next)));

            {
                if ((chunk)->flags & 0x0001u)
                    _spaces__delNextChunk(chunk);
            };
            return;
        }

    if (!(chunk->flags & 0x0001u)) {
    }
};

ThreadContext *_spaces__getCurrentThreadContext(TaskRecord * taskRec, Bool bInsert)
{
    ThreadContext *t = &taskRec->threadContexts[0];
    unsigned i = taskRec->threadContextCount;
    ThreadID id = _spaces__getCurrentThreadID();

    while (i--)
        if (t->id == id)
            return t;
        else
            t++;

    if (bInsert && taskRec->threadContextCount < 25) {
        t->id = id;
        t->handlingError = 0;
        taskRec->threadContextCount++;
        return t;
    } else
        return 0;
};

void _spaces__deleteThreadContext(TaskRecord * taskRec, ThreadContext * t)
{
    *t = taskRec->threadContexts[--taskRec->threadContextCount];
};

static Bool _spaces__validateFreeLists(Chunk *);
static Bool spaces__validateFreeListPage(Page *, PageType);
static Bool spaces__validateFreeListsSmall(Chunk * chunk);
static Bool spaces__validateFreeListsSmall2(Chunk * chunk);
static Bool _spaces__validateFreeListFS(Page *);
static Bool _spaces__validateFreeListVar(Page *);

Bool spaces_chunk_check(SpacesChunk chunk)
{
    Bool result;

    {
        if (!(chunk)) {
            (chunk) = (spaces_default_chunk = spaces_init_default_chunk());
        }
    };
    {
        if ((chunk)->flags & 0x8000u) {
            ThreadID tid_ = pthread_self();
            ThreadLocalChunk *tlp_ = &spaces__threadLocalChunks[tid_ % 997];
            if (tlp_->tid == tid_)
                (chunk) = tlp_->chunk;
        };
    };

    {
        if ((chunk)->smpParent)
            (chunk) = (chunk)->smpParent;
        do { {
                if ((chunk)->flags & 0x0002u) {
                    if ((chunk)->flags & 0x0001u) {
                        if (!_spaces__lockSharedSem(chunk))
                            return 0;
                    } else { {
                            if (!(pthread_mutex_lock(&(&((chunk)->mutex))->m) == 0 && ++(&((chunk)->mutex))->count))
                                return 0;
                            if ((chunk)->mutex.count == 1) {
                                if (((chunk)->flags & 0x0002u)) { {
                                        int i___ = 2;
                                        int k___ = 0;
                                        while (!((((chunk)->lock) && spaces__test_and_clear(&(chunk)->lock)))) {;
                                            if (i___-- == 0) {
                                                spaces__smpYield(k___++);
                                                i___ = 2;
                                            }
                                        }
                                }
                                };
                            }
                    };
                    }
                }
        };
        result = spaces__chunkCheck(chunk);
        {
            if ((chunk)->flags & 0x0002u) {
                if ((chunk)->flags & 0x0001u)
                    _spaces__unlockSharedSem(chunk);
                else { {
                        if ((chunk)->mutex.count == 1) { {
                                if (((chunk)->flags & 0x0002u) && !(chunk)->locktid) {
                                    if (!spaces__preForkLock) { {
                                            if ((chunk)->smpFreeQueue)
                                                spaces__smpFlushQueue(chunk);
                                    };
                                    }
                                    ((chunk)->lock = 1);
                                }
                        };
                        }
                        (--(&((chunk)->mutex))->count, pthread_mutex_unlock(&(&((chunk)->mutex))->m));
                };
                }
            }
        };
        } while (((chunk) = (chunk)->smpNextChunk) != 0 && (chunk) != (chunk)->smpParent);
    }
    return result;
};

Bool spaces__chunkCheck(SpacesChunk chunk)
{
    SpacesChunkEntry ChunkEntry;
    SpacesChunkStatus result;
    Bool bError = 0;

    ChunkEntry.entry = 0;

    {
        do {
            result = _spaces__walkChunk((chunk), &ChunkEntry, 0, 0);
            if (result == SPACES_CHUNK_CORRUPT)
                bError = 1;
        } while (result == SPACES_CHUNK_OK || result == SPACES_CHUNK_CORRUPT);
        if (result == SPACES_CHUNK_END)
            if (!_spaces__validateFreeLists((chunk)))
                result = SPACES_CHUNK_CORRUPT_FATAL;
    }
    if (result != SPACES_CHUNK_END)
        bError = 1;

    return !bError;
};

SpacesChunkStatus spaces__checkChunkPage(SpacesChunkEntry * entry)
{
    SpacesChunk chunk = entry->chunk;
    SpacesChunkStatus result = SPACES_CHUNK_CORRUPT;
    Bool bError = 0;
    PageHeader *pgHdr = (PageHeader *) entry->reserved_ptr;

    entry->entry = 0;

    {
        if ((chunk)->flags & 0x0002u) {
            if ((chunk)->flags & 0x0001u) {
                if (!_spaces__lockSharedSem(chunk))
                    return SPACES_CHUNK_CORRUPT;
            } else { {
                    if (!(pthread_mutex_lock(&(&((chunk)->mutex))->m) == 0 && ++(&((chunk)->mutex))->count))
                        return SPACES_CHUNK_CORRUPT;
                    if ((chunk)->mutex.count == 1) {
                        if (((chunk)->flags & 0x0002u)) { {
                                int i___ = 2;
                                int k___ = 0;
                                while (!((((chunk)->lock) && spaces__test_and_clear(&(chunk)->lock)))) {;
                                    if (i___-- == 0) {
                                        spaces__smpYield(k___++);
                                        i___ = 2;
                                    }
                                }
                        }
                        };
                    }
            };
            }
        }
    };

    if (pgHdr) {
        if (((PageType) (((pgHdr)->moveableFlags & 0x7000) >> 12)) >= ((PageType) 7)
            || ((PageType) (((pgHdr)->moveableFlags & 0x7000) >> 12)) == ((PageType) 6)
            || chunk->rovers[((PageType) (((pgHdr)->moveableFlags & 0x7000) >> 12))] == 0)
            entry->reserved_ptr = pgHdr = 0;
        else {

        }
    }

    if (!bError) {
        {
            do {
                result = _spaces__walkChunk((chunk), entry, 0, pgHdr != 0);
                if (result == SPACES_CHUNK_CORRUPT)
                    bError = 1;
                if (!pgHdr)
                    pgHdr = (PageHeader *) entry->reserved_ptr;
                else if (pgHdr != (PageHeader *) entry->reserved_ptr)
                    break;
            } while (result == SPACES_CHUNK_OK || result == SPACES_CHUNK_CORRUPT);
        }
        if (result == SPACES_CHUNK_END || result == SPACES_CHUNK_OK) {
            if (pgHdr
                && !spaces__validateFreeListPage(pgHdr->page, ((PageType) (((pgHdr)->moveableFlags & 0x7000) >> 12))
                ))
                bError = 1;
        } else
            bError = 1;

    }

    {
        if ((chunk)->flags & 0x0002u) {
            if ((chunk)->flags & 0x0001u)
                _spaces__unlockSharedSem(chunk);
            else { {
                    if ((chunk)->mutex.count == 1) { {
                            if (((chunk)->flags & 0x0002u) && !(chunk)->locktid) {
                                if (!spaces__preForkLock) { {
                                        if ((chunk)->smpFreeQueue)
                                            spaces__smpFlushQueue(chunk);
                                };
                                }
                                ((chunk)->lock = 1);
                            }
                    };
                    }
                    (--(&((chunk)->mutex))->count, pthread_mutex_unlock(&(&((chunk)->mutex))->m));
            };
            }
        }
    };

    return result;
};

static Bool _spaces__validateFreeLists(Chunk * chunk)
{
    Bool bResult = 1;
    register PageHeader *rover;
    PageType i;

    for (i = 0; i < ((PageType) 7); i++)
        if (i == ((PageType) 3))
            continue;
        else if ((rover = chunk->rovers[i]) != 0) {
            do {
                bResult = spaces__validateFreeListPage(rover->page, i);
            }
            while (bResult && (rover = rover->next) != chunk->rovers[i]);
            if (!bResult)
                break;
        }

    if (bResult) {
        if (chunk->allocSmallFn == SPACES_SMALL_V5) {
            if (!spaces__validateFreeListsSmall2(chunk))
                return 0;
        } else {

            if (!spaces__validateFreeListsSmall(chunk))
                return 0;
        }
    }

    return bResult;
};

static Bool spaces__validateFreeListPage(Page * page, PageType type)
{
    Bool bResult = 0;

    {
        switch (type) {
        case ((PageType) 4):
            bResult = 1;
            break;
        case ((PageType) 0):
        case ((PageType) 1):
        case ((PageType) 5):
            bResult = _spaces__validateFreeListFS((page));
            break;
        case ((PageType) 3):
        case ((PageType) 6):
            bResult = 1;
            break;
        default:
            break;
        };
    }
    return bResult;
};

static Bool spaces__validateFreeListsSmall(Chunk * chunk)
{
    unsigned i;

    for (i = 0;
         i <
         (((2048 +
            ((PageSize)
             ((PageSize) ((PageSize) (0) + (PageSize) ((sizeof(double)) - 1u)) &
              ((PageSize) (~((PageSize) ((sizeof(double)) - 1u)))))) - 0) >> 3) + 1); i++) {
        FreeSmallBlock *fast = chunk->smallFreeLists[i].block;

        if (fast) {

            if (fast->next)
                fast = fast->next;

            if (spaces__isBlockInUseSmall(chunk, fast) == -1)
                return 0;
        }
    }

    return 1;
};

static Bool spaces__validateFreeListsSmall2(Chunk * chunk)
{
    unsigned i;
    int pageCount = 0;
    PageHeader *rover;

    for (i = 0;
         i <
         (((2048 +
            ((PageSize)
             ((PageSize) ((PageSize) (0) + (PageSize) ((sizeof(double)) - 1u)) &
              ((PageSize) (~((PageSize) ((sizeof(double)) - 1u)))))) - 0) >> 3) + 1); i++) {
        SmallFreeList *head = &chunk->smallFreeLists[i];
        Page *page = head->page;

        if (page) {
            do {
                if (!
                    (((page)->flagsAndSignature & 0xFFF0u) == ((PageType) 0xCAD0)
                     && ((PageType) ((page)->flagsAndSignature & ((PageType) 0x000F))) < ((PageType) 7)))
                    return 0;

                if (page->hdr.fs.index != i)
                    return 0;

                pageCount++;
                page = page->hdr.fs.next;
            }
            while (page != head->page);
        }
    }

    if ((rover = chunk->rovers[((PageType) 5)]) != 0) {
        do {

            if (rover->page->hdr.fs.head == 0)
                pageCount--;
        }
        while ((rover = rover->next) != chunk->rovers[((PageType) 5)]);
    }

    if (pageCount != 0)
        return 0;

    return 1;
};

__attribute__((unused))
static Bool _spaces__validateFreeListVar(Page * page)
{
    register FreeBlock *end = page->hdr.var.freeList;
    register FreeBlock *block = end, *fast = block, *slow = block;
    Bool bRoverOK = 0;

    do {

        if (block->next->prev != block || block->prev->next != block)
            goto invalidBlock;

        if (block == end) {
            if (((block)->sizeAndTags & ((PageSize) (~3u))) != 0 || !((block)->sizeAndTags & ((PageSize) 1u)))
                goto invalidBlock;
        } else if (((block)->sizeAndTags & ((PageSize) 1u)) || !((block)->sizeAndTags & ((PageSize) 2u))
                   || ((block)->sizeAndTags & ((PageSize) (~3u))) == 0)
            goto invalidBlock;

        if (fast != end && (fast = fast->next) != end && (fast = fast->next) == (slow = slow->next))
            goto invalidBlock;

        if (block == page->hdr.var.rover)
            bRoverOK = 1;
    }
    while ((block = block->next) != end);

    if (bRoverOK)
        return 1;

  invalidBlock:
    _spaces__invokeErrorHandler1(page->chunk, SPACES_ERR_BAD_FREE_BLOCK);
    return 0;
};

static Bool _spaces__validateFreeListFS(Page * page)
{
    if (page->hdr.fs.freeList && page->hdr.fs.freeList->next
        && _spaces__isBlockInUseFS(page, page->chunk, page->hdr.fs.freeList->next) == -1) {
        _spaces__invokeErrorHandler1(page->chunk, SPACES_ERR_BAD_FREE_BLOCK);
        return 0;
    }

    return 1;
};

SpacesPointerStatus spaces_chunk_ptr_check(SpacesChunk chunk, void *ptr)
{
    Page *page;
    SpacesPointerStatus result = SPACES_PTR_OK;


    if (!_spaces__sysValidatePtr(ptr, sizeof(double), 0x0002 | 0x0200)) {
        _spaces__invokeErrorHandler1(0, SPACES_ERR_BAD_POINTER);
        return SPACES_PTR_WILD;
    }

    {
    };

    page = ((Page *) (((unsigned long) (ptr) & ((0x7fffffffffffffffL * 2UL + 1UL)
                                                - (0x00010000lu - 1))) +
                      ((PageSize)
                       ((PageSize) ((PageSize) (sizeof(Area)) + (PageSize) ((sizeof(double)) - 1u)) &
                        ((PageSize) (~((PageSize) ((sizeof(double)) - 1u))))))));
    if (!_spaces__sysValidatePtr(page, sizeof(Page), 0x0002 | 0x1000)
        || !(((page)->flagsAndSignature & 0xFFF0u) == ((PageType) 0xCAD0)
             && ((PageType) ((page)->flagsAndSignature & ((PageType) 0x000F))) < ((PageType) 7))
        || (chunk && chunk->smpParent != page->chunk->smpParent)
        )
        return SPACES_PTR_WILD;

    chunk = page->chunk;

    {
        if ((chunk)->flags & 0x0002u) {
            if ((chunk)->flags & 0x0001u) {
                if (!_spaces__lockSharedSem(chunk))
                    return SPACES_PTR_WILD;
            } else { {
                    if (!(pthread_mutex_lock(&(&((chunk)->mutex))->m) == 0 && ++(&((chunk)->mutex))->count))
                        return SPACES_PTR_WILD;
                    if ((chunk)->mutex.count == 1) {
                        if (((chunk)->flags & 0x0002u)) { {
                                int i___ = 2;
                                int k___ = 0;
                                while (!((((chunk)->lock) && spaces__test_and_clear(&(chunk)->lock)))) {;
                                    if (i___-- == 0) {
                                        spaces__smpYield(k___++);
                                        i___ = 2;
                                    }
                                }
                        }
                        };
                    }
            };
            }
        }
    };

    switch (((PageType) ((page)->flagsAndSignature & ((PageType) 0x000F)))) {
    case ((PageType) 4):
        if (!spaces__isBlockInUseSmall(chunk, (FreeSmallBlock *) ptr))
            result = SPACES_PTR_FREE;
        break;

    case ((PageType) 0):

    case ((PageType) 1):
    case ((PageType) 5):
        {
            Bool bInUse;
            {
                bInUse = _spaces__isBlockInUseFS((page), chunk, ((FSBlock *) ((char *) (((Block *) (ptr))) - 0)));
            }

            if (!bInUse)
                result = SPACES_PTR_FREE;
        }
    }

    {
        if ((chunk)->flags & 0x0002u) {
            if ((chunk)->flags & 0x0001u)
                _spaces__unlockSharedSem(chunk);
            else { {
                    if ((chunk)->mutex.count == 1) { {
                            if (((chunk)->flags & 0x0002u) && !(chunk)->locktid) {
                                if (!spaces__preForkLock) { {
                                        if ((chunk)->smpFreeQueue)
                                            spaces__smpFlushQueue(chunk);
                                };
                                }
                                ((chunk)->lock = 1);
                            }
                    };
                    }
                    (--(&((chunk)->mutex))->count, pthread_mutex_unlock(&(&((chunk)->mutex))->m));
            };
            }
        }
    };

    return result;
};

static SpacesChunkStatus _spaces__walkChunkExternal(Page * page, SpacesChunkEntry * entry);
static SpacesChunkStatus spaces__walkChunkSmall(Page * page, SpacesChunkEntry * entry, Bool bCheckFree);
static SpacesChunkStatus spaces__walkChunkSmall2(Page * page, SpacesChunkEntry * entry, Bool bCheckFree);
__attribute__((unused))
static SpacesChunkStatus _spaces__walkChunkVar(Page * page, SpacesChunkEntry * entry);
static SpacesChunkStatus _spaces__walkChunkFS(Page * page, SpacesChunkEntry * entry, Bool bCheckFree);
static void _spaces__setChunkInfo(Chunk * chunk, SpacesChunkInfo * pi);

SpacesVersion spaces_version()
{
    return (11 << 12u) | (2 << 8u) | 0;
};

size_t spaces_chunk_size(Chunk * chunk)
{
    size_t size = 0;

    {
        if (!(chunk)) {
            (chunk) = (spaces_default_chunk = spaces_init_default_chunk());
        }
    };
    {
        if ((chunk)->flags & 0x8000u) {
            ThreadID tid_ = pthread_self();
            ThreadLocalChunk *tlp_ = &spaces__threadLocalChunks[tid_ % 997];
            if (tlp_->tid == tid_)
                (chunk) = tlp_->chunk;
        };
    };

    {
        if ((chunk)->smpParent)
            (chunk) = (chunk)->smpParent;
        do {
            size += ((chunk)->pageTotal);
        } while (((chunk) = (chunk)->smpNextChunk) != 0 && (chunk) != (chunk)->smpParent);
    };

    return size;
};

size_t spaces_chunk_count(Chunk * chunk)
{
    size_t result = 0;

    {
        if (!(chunk)) {
            (chunk) = (spaces_default_chunk = spaces_init_default_chunk());
        }
    };
    {
        if ((chunk)->flags & 0x8000u) {
            ThreadID tid_ = pthread_self();
            ThreadLocalChunk *tlp_ = &spaces__threadLocalChunks[tid_ % 997];
            if (tlp_->tid == tid_)
                (chunk) = tlp_->chunk;
        };
    };

    {
        if ((chunk)->smpParent)
            (chunk) = (chunk)->smpParent;
        do { {
                if ((chunk)->flags & 0x0002u) {
                    if ((chunk)->flags & 0x0001u) {
                        if (!_spaces__lockSharedSem(chunk))
                            return (size_t) (-1);
                    } else { {
                            if (!(pthread_mutex_lock(&(&((chunk)->mutex))->m) == 0 && ++(&((chunk)->mutex))->count))
                                return (size_t) (-1);
                            if ((chunk)->mutex.count == 1) {
                                if (((chunk)->flags & 0x0002u)) { {
                                        int i___ = 2;
                                        int k___ = 0;
                                        while (!((((chunk)->lock) && spaces__test_and_clear(&(chunk)->lock)))) {;
                                            if (i___-- == 0) {
                                                spaces__smpYield(k___++);
                                                i___ = 2;
                                            }
                                        }
                                }
                                };
                            }
                    };
                    }
                }
        };
        result += _spaces__chunkCount(chunk);
        {
            if ((chunk)->flags & 0x0002u) {
                if ((chunk)->flags & 0x0001u)
                    _spaces__unlockSharedSem(chunk);
                else { {
                        if ((chunk)->mutex.count == 1) { {
                                if (((chunk)->flags & 0x0002u) && !(chunk)->locktid) {
                                    if (!spaces__preForkLock) { {
                                            if ((chunk)->smpFreeQueue)
                                                spaces__smpFlushQueue(chunk);
                                    };
                                    }
                                    ((chunk)->lock = 1);
                                }
                        };
                        }
                        (--(&((chunk)->mutex))->count, pthread_mutex_unlock(&(&((chunk)->mutex))->m));
                };
                }
            }
        };
        } while (((chunk) = (chunk)->smpNextChunk) != 0 && (chunk) != (chunk)->smpParent);
    }

    return result;
};

size_t _spaces__chunkCount(Chunk * chunk)
{
    size_t count = 0;

    {
        register PageHeader *rover;
        PageType i;
        for (i = 0; i < ((PageType) 7); i++)
            if ((rover = (chunk)->rovers[i]) != 0)
                do
                    count += rover->page->allocCount;
                while ((rover = rover->next) != (chunk)->rovers[i]);
    }
    return count;
};

SpacesChunkStatus spaces_chunk_walk(Chunk * chunk, SpacesChunkEntry * entry)
{
    SpacesChunkStatus result;

    {
        if (!(chunk)) {
            (chunk) = (spaces_default_chunk = spaces_init_default_chunk());
        }
    };
    {
        if ((chunk)->flags & 0x8000u) {
            ThreadID tid_ = pthread_self();
            ThreadLocalChunk *tlp_ = &spaces__threadLocalChunks[tid_ % 997];
            if (tlp_->tid == tid_)
                (chunk) = tlp_->chunk;
        };
    };

    if (!entry->entry)
        entry->chunk = chunk;

    if (chunk->smpParent) {
        if (entry->entry)
            chunk = entry->reserved_chunk;
        else
            chunk = chunk->smpParent;
    }
  nextSubChunk:

    {
        if ((chunk)->flags & 0x0002u) {
            if ((chunk)->flags & 0x0001u) {
                if (!_spaces__lockSharedSem(chunk))
                    return SPACES_CHUNK_CORRUPT_FATAL;
            } else { {
                    if (!(pthread_mutex_lock(&(&((chunk)->mutex))->m) == 0 && ++(&((chunk)->mutex))->count))
                        return SPACES_CHUNK_CORRUPT_FATAL;
                    if ((chunk)->mutex.count == 1) {
                        if (((chunk)->flags & 0x0002u)) { {
                                int i___ = 2;
                                int k___ = 0;
                                while (!((((chunk)->lock) && spaces__test_and_clear(&(chunk)->lock)))) {;
                                    if (i___-- == 0) {
                                        spaces__smpYield(k___++);
                                        i___ = 2;
                                    }
                                }
                        }
                        };
                    }
            };
            }
        }
    };

    {
        result = _spaces__walkChunk((chunk), entry, 1, 0);
    }

    {
        if ((chunk)->flags & 0x0002u) {
            if ((chunk)->flags & 0x0001u)
                _spaces__unlockSharedSem(chunk);
            else { {
                    if ((chunk)->mutex.count == 1) { {
                            if (((chunk)->flags & 0x0002u) && !(chunk)->locktid) {
                                if (!spaces__preForkLock) { {
                                        if ((chunk)->smpFreeQueue)
                                            spaces__smpFlushQueue(chunk);
                                };
                                }
                                ((chunk)->lock = 1);
                            }
                    };
                    }
                    (--(&((chunk)->mutex))->count, pthread_mutex_unlock(&(&((chunk)->mutex))->m));
            };
            }
        }
    };

    if (result == SPACES_CHUNK_END && chunk->smpNextChunk != chunk->smpParent) {
        chunk = chunk->smpNextChunk;
        entry->entry = 0;
        goto nextSubChunk;
    }

    return result;
};

SpacesChunkStatus _spaces__walkChunk(Chunk * chunk, SpacesChunkEntry * entry, Bool bCheckFree, Bool bRoverValid)
{
    SpacesChunkStatus result;
    register PageHeader *rover;
    Page *page;
    PageType type;

    if (entry->entry || bRoverValid) {
        rover = ((PageHeader *) (entry->reserved_ptr));
        type = ((PageType) (((rover)->moveableFlags & 0x7000) >> 12));

    } else {
        rover = chunk->rovers[type = 0];
        entry->reserved_chunk = chunk;
    }

    if (entry->entry) {
        entry->entry = entry->entry;
    }

    for (;;) {
        while (!rover) {
            if (++type == ((PageType) 7))
                return SPACES_CHUNK_END;
            rover = chunk->rovers[type];
        }
        page = rover->page;

        {
            switch (type) {
            case ((PageType) 4):
                result = spaces__walkChunkSmall((page), entry, bCheckFree);
                break;
            case ((PageType) 5):
                result = spaces__walkChunkSmall2((page), entry, bCheckFree);
                break;
            case ((PageType) 0):
            case ((PageType) 1):
                result = _spaces__walkChunkFS((page), entry, bCheckFree);
                break;
            case ((PageType) 3):
                result = _spaces__walkChunkExternal((page), entry);
                bCheckFree = 1;
                break;
            case ((PageType) 6):
                if (entry->entry)
                    result = SPACES_CHUNK_END;
                else {
                    entry->entry = page;
                    entry->type = SPACES_BLOCK_FREE;
                    entry->size = _spaces__sysSize(page);
                    entry->isInUse = 0;
                    entry->lockCount = 0;
                    result = SPACES_CHUNK_OK;
                }
                break;
            default:
                break;
            };
        }
        if (result != SPACES_CHUNK_END) {
            if (result == SPACES_CHUNK_CORRUPT_FATAL) {

                _spaces__invokeErrorHandler1(page->chunk, SPACES_ERR_BAD_BLOCK);
            }
            break;
        }
        entry->entry = 0;
        if ((rover = rover->next) == chunk->rovers[type])
            rover = 0;
    }

    entry->reserved_ptr = rover;

    return result;
};

static SpacesChunkStatus _spaces__walkChunkExternal(Page * page, SpacesChunkEntry * entry)
{
    if (entry->entry)
        return SPACES_CHUNK_END;

    entry->entry =
        (char *) page +
        ((PageSize)
         ((PageSize) ((PageSize) (sizeof(Page) + (0)) + (PageSize) ((sizeof(double)) - 1u)) &
          ((PageSize) (~((PageSize) ((sizeof(double)) - 1u))))));
    entry->size =
        _spaces__sysSize(page) -
        ((PageSize)
         ((PageSize) ((PageSize) (sizeof(Page) + (0)) + (PageSize) ((sizeof(double)) - 1u)) &
          ((PageSize) (~((PageSize) ((sizeof(double)) - 1u))))));

    entry->lockCount = 0;
    entry->isInUse = 1;

    switch (page->hdr.ext.type) {
    case ((PageType) 0):
        entry->type = SPACES_BLOCK_VAR_FIXED;
        break;
    default:
        return SPACES_CHUNK_CORRUPT_FATAL;
    }

    return SPACES_CHUNK_OK;
};

static SpacesChunkStatus spaces__walkChunkSmall(Page * page, SpacesChunkEntry * entry, Bool bCheckFree)
{
    char *block;
    unsigned index;

    if (entry->entry) {
        if ((char *) (entry->entry) == page->hdr.fs.free)
            block = page->hdr.fs.end;
        else {
            block = (char *) ((Block *) (entry->entry)) +
                ((((*((unsigned char *) (((Block *) (entry->entry))) - 0 - 1))) << 3) +
                 ((PageSize)
                  ((PageSize) ((PageSize) (0 + 1) + (PageSize) ((sizeof(double)) - 1u)) &
                   ((PageSize) (~((PageSize) ((sizeof(double)) - 1u)))))));

            if ((block != page->hdr.fs.end
                 && block <
                 ((char
                   *) ((Block *) ((char *) (page) +
                                  (((PageSize)
                                    ((PageSize)
                                     ((PageSize) (sizeof(Page) + (0 + 1)) +
                                      (PageSize) ((sizeof(double)) -
                                                  1u)) & ((PageSize) (~((PageSize) ((sizeof(double)) - 1u)))))))))))
                || (block > page->hdr.fs.free))
                return SPACES_CHUNK_CORRUPT_FATAL;
        }
    } else {
        size_t pageSize = (PageSize) ((page->hdr.fs.end - (char *) page) - 1);

        if (pageSize > (0x7fffffffffffffffL * 2UL + 1UL)
            || !_spaces__sysValidatePtr(page, pageSize, 0x0002 | 0x1000)
            || _spaces__sysSize(page) - 1 < pageSize
            ||
            (page->hdr.fs.free <
             ((char
               *) ((Block *) ((char *) (page) +
                              (((PageSize)
                                ((PageSize) ((PageSize) (sizeof(Page) + (0 + 1)) + (PageSize) ((sizeof(double)) - 1u)) &
                                 ((PageSize) (~((PageSize) ((sizeof(double)) - 1u))))))))))
            )
            || (page->hdr.fs.free > page->hdr.fs.end)) {

            return SPACES_CHUNK_CORRUPT_FATAL;
        }

        block =
            ((char
              *) ((Block *) ((char *) (page) +
                             (((PageSize)
                               ((PageSize) ((PageSize) (sizeof(Page) + (0 + 1)) + (PageSize) ((sizeof(double)) - 1u)) &
                                ((PageSize) (~((PageSize) ((sizeof(double)) - 1u))))))))));
    }

    if (block == page->hdr.fs.end)
        return SPACES_CHUNK_END;
    else if (block == page->hdr.fs.free) {
        entry->size = page->hdr.fs.end - page->hdr.fs.free;

        entry->isInUse = 0;
        bCheckFree = 0;

    } else {
        index = (*((unsigned char *) (block) - 0 - 1));
        if (index >=
            (((2048 +
               ((PageSize)
                ((PageSize) ((PageSize) (0) + (PageSize) ((sizeof(double)) - 1u)) &
                 ((PageSize) (~((PageSize) ((sizeof(double)) - 1u)))))) - 0) >> 3) + 1)) {

            return SPACES_CHUNK_CORRUPT_FATAL;
        }
        entry->size =
            ((((index) << 3) +
              ((PageSize)
               ((PageSize) ((PageSize) (0 + 1) + (PageSize) ((sizeof(double)) - 1u)) &
                ((PageSize) (~((PageSize) ((sizeof(double)) - 1u))))))) - 0 - 1);
    }

    entry->entry = block;
    entry->type = SPACES_BLOCK_VAR_FIXED;
    entry->lockCount = 0;
    if (bCheckFree) {

        if ((entry->isInUse = spaces__isBlockInUseSmall(entry->reserved_chunk, (FreeSmallBlock *) block)) == -1)
            return SPACES_CHUNK_CORRUPT_FATAL;
    }

    return SPACES_CHUNK_OK;
};

static SpacesChunkStatus spaces__walkChunkSmall2(Page * page, SpacesChunkEntry * entry, Bool bCheckFree)
{
    char *block;

    if (entry->entry) {
        if ((char *) ((FSBlock *) ((char *) (entry->entry) - 0)) == page->hdr.fs.free)
            block = page->hdr.fs.end;
        else {
            block = (char *) ((Block *) (entry->entry)) +
                ((((page->hdr.fs.index) << 3) +
                  ((PageSize)
                   ((PageSize) ((PageSize) (0) + (PageSize) ((sizeof(double)) - 1u)) &
                    ((PageSize) (~((PageSize) ((sizeof(double)) - 1u))))))) - 0);

            if ((block != page->hdr.fs.end
                 && block <
                 ((char
                   *) ((FSBlock
                        *) (((char
                              *) ((Block *) ((char *) (page) +
                                             (((PageSize)
                                               ((PageSize)
                                                ((PageSize) (sizeof(Page) + (0)) +
                                                 (PageSize) ((sizeof(double)) -
                                                             1u)) &
                                                ((PageSize) (~((PageSize) ((sizeof(double)) - 1u)))))))))) - 0))))
                || (block > page->hdr.fs.free))
                return SPACES_CHUNK_CORRUPT_FATAL;
        }
    } else {
        size_t pageSize = (PageSize) ((page->hdr.fs.end - (char *) page) - 1);

        if (pageSize > (0x7fffffffffffffffL * 2UL + 1UL)
            || !_spaces__sysValidatePtr(page, pageSize, 0x0002 | 0x1000)
            || _spaces__sysSize(page) - 1 < pageSize
            ||
            (page->hdr.fs.free <
             ((char
               *) ((FSBlock
                    *) (((char
                          *) ((Block *) ((char *) (page) +
                                         (((PageSize)
                                           ((PageSize)
                                            ((PageSize) (sizeof(Page) + (0)) +
                                             (PageSize) ((sizeof(double)) -
                                                         1u)) &
                                            ((PageSize) (~((PageSize) ((sizeof(double)) - 1u)))))))))) - 0)))
            )
            || (page->hdr.fs.free > page->hdr.fs.end)) {

            return SPACES_CHUNK_CORRUPT_FATAL;
        }

        block =
            ((char
              *) ((FSBlock
                   *) (((char
                         *) ((Block *) ((char *) (page) +
                                        (((PageSize)
                                          ((PageSize)
                                           ((PageSize) (sizeof(Page) + (0)) +
                                            (PageSize) ((sizeof(double)) -
                                                        1u)) &
                                           ((PageSize) (~((PageSize) ((sizeof(double)) - 1u)))))))))) - 0)));
    }

    if (block == page->hdr.fs.end)
        return SPACES_CHUNK_END;
    else if (block == page->hdr.fs.free) {
        entry->size = page->hdr.fs.end - page->hdr.fs.free;

        entry->isInUse = 0;
        bCheckFree = 0;

    } else {
        if (page->hdr.fs.index >=
            (((2048 +
               ((PageSize)
                ((PageSize) ((PageSize) (0) + (PageSize) ((sizeof(double)) - 1u)) &
                 ((PageSize) (~((PageSize) ((sizeof(double)) - 1u)))))) - 0) >> 3) + 1)) {

            return SPACES_CHUNK_CORRUPT_FATAL;
        }
        entry->size =
            ((((page->hdr.fs.index) << 3) +
              ((PageSize)
               ((PageSize) ((PageSize) (0) + (PageSize) ((sizeof(double)) - 1u)) &
                ((PageSize) (~((PageSize) ((sizeof(double)) - 1u))))))) - 0);
    }

    entry->entry = block + 0;
    entry->type = SPACES_BLOCK_VAR_FIXED;
    entry->lockCount = 0;
    if (bCheckFree) {

        if ((entry->isInUse = _spaces__isBlockInUseFS(page, entry->reserved_chunk, (FSBlock *) block)) == -1)
            return SPACES_CHUNK_CORRUPT_FATAL;
    }

    return SPACES_CHUNK_OK;
};

int spaces__isBlockInUseSmall(Chunk * chunk, FreeSmallBlock * block)
{
    unsigned index = (*((unsigned char *) (block) - 0 - 1));
    FreeSmallBlock *fast = chunk->smallFreeLists[index].block, *slow = fast;

    while (slow) {

        if (block == slow)
            return 0;

        slow = slow->next;
        if (slow && fast && (fast = fast->next) != 0 && (fast = fast->next) == slow) {

            _spaces__invokeErrorHandler1(chunk, SPACES_ERR_BAD_FREE_BLOCK);
            return -1;
        }
    }

    return 1;
};

__attribute__((unused))
static SpacesChunkStatus _spaces__walkChunkVar(Page * page, SpacesChunkEntry * entry)
{
    Block *block;

    if (entry->entry) {
        block = (Block *) (entry->entry) - 1;
        block =
            ((Block *) ((char *) (block) +
                        (((block)->sizeAndTags & ((PageSize) 1u)) ? ((block)->
                                                                     sizeAndTags &
                                                                     ((PageSize)
                                                                      (~((PageSize) ((0x7fffffffffffffffL * 2UL + 1UL)
                                                                                     -
                                                                                     ((0x7fffffffffffffffL * 2UL + 1UL)
                                                                                      >> 1)) | 3u)))) : ((block)->
                                                                                                         sizeAndTags &
                                                                                                         ((PageSize)
                                                                                                          (~3u))))));

        if (block <
            ((Block
              *) (((char
                    *) ((Block *) ((char *) (page) +
                                   (((PageSize)
                                     ((PageSize)
                                      ((PageSize) (sizeof(Page) + (sizeof(Block))) +
                                       (PageSize) ((sizeof(double)) -
                                                   1u)) & ((PageSize) (~((PageSize) ((sizeof(double)) - 1u)))))))))) -
                  sizeof(Block)))
            || block > (Block *) page->hdr.var.freeList)
            return SPACES_CHUNK_CORRUPT_FATAL;
    } else {
        size_t pageSize = (PageSize)
            (((char *) page->hdr.var.freeList - (char *) page) + sizeof(FreeBlock) - 1);

        if (pageSize > (0x7fffffffffffffffL * 2UL + 1UL)
            || !_spaces__sysValidatePtr(page, pageSize, 0x0002 | 0x1000)
            || _spaces__sysSize(page) - 1 < pageSize) {

            return SPACES_CHUNK_CORRUPT_FATAL;
        }

        block =
            ((Block
              *) (((char
                    *) ((Block *) ((char *) (page) +
                                   (((PageSize)
                                     ((PageSize)
                                      ((PageSize) (sizeof(Page) + (sizeof(Block))) +
                                       (PageSize) ((sizeof(double)) -
                                                   1u)) & ((PageSize) (~((PageSize) ((sizeof(double)) - 1u)))))))))) -
                  sizeof(Block)));
    }

    if (block == (Block *) page->hdr.var.freeList)
        return SPACES_CHUNK_END;

    entry->entry = block + 1;
    entry->type = ((PageType) ((page)->flagsAndSignature & ((PageType) 0x000F))) == ((PageType) 0)
        ? SPACES_BLOCK_VAR_FIXED : SPACES_BLOCK_VAR_MOVEABLE;
    if ((entry->isInUse = ((block)->sizeAndTags & ((PageSize) 1u))) != 0) {
        entry->size = ((block)->sizeAndTags & ((PageSize) (~((PageSize) ((0x7fffffffffffffffL * 2UL + 1UL)
                                                                         - ((0x7fffffffffffffffL * 2UL + 1UL)
                                                                            >> 1)) | 3u)))) - sizeof(Block)
            - (0);
        entry->lockCount = 0;
    } else {
        entry->size = ((block)->sizeAndTags & ((PageSize) (~3u))) - sizeof(Block);
        entry->lockCount = 0;
    }

    return SPACES_CHUNK_OK;
};

static SpacesChunkStatus _spaces__walkChunkFS(Page * page, SpacesChunkEntry * entry, Bool bCheckFree)
{
    PageSize blockSize = entry->reserved_chunk->blockSizeFS;
    char *block;

    if (entry->entry) {
        block = (char *) ((Block *) (entry->entry)) + blockSize;
        if ((block != page->hdr.fs.end
             && block <
             (char
              *) ((FSBlock
                   *) (((char
                         *) ((Block *) ((char *) (page) +
                                        (((PageSize)
                                          ((PageSize)
                                           ((PageSize) (sizeof(Page) + (0)) +
                                            (PageSize) ((sizeof(double)) -
                                                        1u)) &
                                           ((PageSize) (~((PageSize) ((sizeof(double)) - 1u)))))))))) - 0)))
            || (block > page->hdr.fs.end))
            return SPACES_CHUNK_CORRUPT_FATAL;
    } else {
        size_t pageSize = (PageSize) ((page->hdr.fs.end - (char *) page) - 1);

        if (pageSize > (0x7fffffffffffffffL * 2UL + 1UL)
            || !_spaces__sysValidatePtr(page, pageSize, 0x0002 | 0x1000)
            || _spaces__sysSize(page) - 1 < pageSize
            ||
            (page->hdr.fs.freeList
             && (page->hdr.fs.freeList <
                 ((FSBlock
                   *) (((char
                         *) ((Block *) ((char *) (page) +
                                        (((PageSize)
                                          ((PageSize)
                                           ((PageSize) (sizeof(Page) + (0)) +
                                            (PageSize) ((sizeof(double)) -
                                                        1u)) &
                                           ((PageSize) (~((PageSize) ((sizeof(double)) - 1u)))))))))) - 0))
                 || (char *) page->hdr.fs.freeList > page->hdr.fs.end - blockSize))) {

            return SPACES_CHUNK_CORRUPT_FATAL;
        }

        block =
            (char
             *) ((FSBlock
                  *) (((char
                        *) ((Block *) ((char *) (page) +
                                       (((PageSize)
                                         ((PageSize)
                                          ((PageSize) (sizeof(Page) + (0)) +
                                           (PageSize) ((sizeof(double)) -
                                                       1u)) & ((PageSize) (~((PageSize) ((sizeof(double)) - 1u))))))))))
                      - 0));
    }

    if (block == page->hdr.fs.end)
        return SPACES_CHUNK_END;

    entry->entry = block + 0;
    entry->type = SPACES_BLOCK_FIXED;
    entry->size = blockSize;
    entry->lockCount = 0;

    if (bCheckFree) {

        if ((entry->isInUse = _spaces__isBlockInUseFS(page, entry->reserved_chunk, (FSBlock *) block)) == -1)
            return SPACES_CHUNK_CORRUPT_FATAL;
    }

    return SPACES_CHUNK_OK;
};

int _spaces__isBlockInUseFS(Page * page, Chunk * chunk, FSBlock * block)
{
    PageType type = ((PageType) ((page)->flagsAndSignature & ((PageType) 0x000F)));
    PageSize blockSize = (type == ((PageType) 1))
        ? (chunk->blockSizeFS + 0)
        : (((page->hdr.fs.index) << 3) +
           ((PageSize)
            ((PageSize) ((PageSize) (0) + (PageSize) ((sizeof(double)) - 1u)) &
             ((PageSize) (~((PageSize) ((sizeof(double)) - 1u)))))));
    char *end = type == ((PageType) 1) ? page->hdr.fs.end : page->hdr.fs.free;
    register FSBlock *link = page->hdr.fs.freeList;
    FSBlock *last = (FSBlock *) (end - blockSize);
    FSBlock *first =
        ((FSBlock
          *) (((char
                *) ((Block *) ((char *) (page) +
                               (((PageSize)
                                 ((PageSize) ((PageSize) (sizeof(Page) + (0)) + (PageSize) ((sizeof(double)) - 1u)) &
                                  ((PageSize) (~((PageSize) ((sizeof(double)) - 1u)))))))))) - 0));
    register PageSize count = (PageSize) ((PageSize) (end - (char *) first) / blockSize);

    if ((PageSize) (end - (char *) first) % blockSize != 0)
        return -1;

    while (link) {

        if (link < first || link > last || count-- == 0 || (PageSize) ((char *) link - (char *) first)
            % blockSize != 0)
            return -1;

        if (block == link)
            return 0;

        link = link->next;
    }

    return 1;
};

Bool spaces_chunk_info(Chunk * chunk, void *ptr, SpacesChunkInfo * pi)
{

    if (ptr) {
        {
        };

        if (chunk && ((Page *) (((unsigned long) (ptr) & ((0x7fffffffffffffffL * 2UL + 1UL)
                                                          - (0x00010000lu - 1))) +
                                ((PageSize)
                                 ((PageSize) ((PageSize) (sizeof(Area)) + (PageSize) ((sizeof(double)) - 1u)) &
                                  ((PageSize) (~((PageSize) ((sizeof(double)) - 1u))))))))->chunk->smpParent !=
            chunk->smpParent) {
            _spaces__invokeErrorHandler1(chunk, SPACES_ERR_BAD_POINTER);
            return 0;
        }
    }

    if (chunk || !ptr) {
        {
            if (!(chunk)) {
                (chunk) = (spaces_default_chunk = spaces_init_default_chunk());
            }
        };
        {
            if ((chunk)->flags & 0x8000u) {
                ThreadID tid_ = pthread_self();
                ThreadLocalChunk *tlp_ = &spaces__threadLocalChunks[tid_ % 997];
                if (tlp_->tid == tid_)
                    (chunk) = tlp_->chunk;
            };
        };
    } else {
        if (ptr == 0) {
            _spaces__invokeErrorHandler1(0, SPACES_ERR_BAD_CHUNK);
            return 0;
        }

        chunk = ((Page *) (((unsigned long) (ptr) & ((0x7fffffffffffffffL * 2UL + 1UL)
                                                     - (0x00010000lu - 1))) +
                           ((PageSize)
                            ((PageSize) ((PageSize) (sizeof(Area)) + (PageSize) ((sizeof(double)) - 1u)) &
                             ((PageSize) (~((PageSize) ((sizeof(double)) - 1u))))))))->chunk;

        if (chunk->smpParent)
            chunk = chunk->smpParent;

    }

    {
        if ((chunk)->flags & 0x0002u) {
            if ((chunk)->flags & 0x0001u) {
                if (!_spaces__lockSharedSem(chunk))
                    return 0;
            } else { {
                    if (!(pthread_mutex_lock(&(&((chunk)->mutex))->m) == 0 && ++(&((chunk)->mutex))->count))
                        return 0;
                    if ((chunk)->mutex.count == 1) {
                        if (((chunk)->flags & 0x0002u)) { {
                                int i___ = 2;
                                int k___ = 0;
                                while (!((((chunk)->lock) && spaces__test_and_clear(&(chunk)->lock)))) {;
                                    if (i___-- == 0) {
                                        spaces__smpYield(k___++);
                                        i___ = 2;
                                    }
                                }
                        }
                        };
                    }
            };
            }
        }
    };
    {
        _spaces__setChunkInfo((chunk), pi);
    }

    {
        if ((chunk)->flags & 0x0002u) {
            if ((chunk)->flags & 0x0001u)
                _spaces__unlockSharedSem(chunk);
            else { {
                    if ((chunk)->mutex.count == 1) { {
                            if (((chunk)->flags & 0x0002u) && !(chunk)->locktid) {
                                if (!spaces__preForkLock) { {
                                        if ((chunk)->smpFreeQueue)
                                            spaces__smpFlushQueue(chunk);
                                };
                                }
                                ((chunk)->lock = 1);
                            }
                    };
                    }
                    (--(&((chunk)->mutex))->count, pthread_mutex_unlock(&(&((chunk)->mutex))->m));
            };
            }
        }
    };

    return 1;
};

SpacesChunkStatus spaces_chunk_first(SpacesChunkInfo * pi, Bool bAllTasks)
{

    if (!pi)
        return SPACES_CHUNK_CORRUPT;

    pi->chunk = 0;

    return spaces_chunk_next(pi, bAllTasks);
};

SpacesChunkStatus spaces_chunk_next(SpacesChunkInfo * pi, Bool bAllTasks)
{
    TaskRecord *taskRec;
    Bool bFirst;
    SpacesChunk taskChunk; (void)taskChunk;
    SpacesChunkStatus result = SPACES_CHUNK_OK;


    if (!pi)
        return SPACES_CHUNK_CORRUPT;

    if (pi->chunk) {
        {
            if (!(pi->chunk)) {
                (pi->chunk) = (spaces_default_chunk = spaces_init_default_chunk());
            }
        };
    }

  nextSubChunk:

    {
        if (!spaces__createAndEnterMutex(&spaces__mutexGlobal))
            return SPACES_CHUNK_CORRUPT;
    };

    if (pi->chunk) {
        taskChunk = pi->chunk;
        pi->chunk =
            (*(((pi->chunk)->flags & 0x0001u) ? _spaces__getNextChunk(pi->chunk) : &((pi->chunk)->task.private_.next)));
        bFirst = 0;
    } else
        bFirst = 1;
    if (!pi->chunk) {

        (void) bAllTasks;
        taskRec = bFirst ? (&_spaces__TaskRecord) : 0;
        if (result == SPACES_CHUNK_OK && (!taskRec || !taskRec->chunks))
            result = SPACES_CHUNK_END;
        else
            pi->chunk = taskRec->chunks;
    }

    {
        if (!spaces__preInitThreads)
            (--(&spaces__mutexGlobal)->count, pthread_mutex_unlock(&(&spaces__mutexGlobal)->m));
    };

    if (pi->chunk && pi->chunk->smpParent && pi->chunk != pi->chunk->smpParent)
        goto nextSubChunk;

    if (result == SPACES_CHUNK_OK) {
        taskChunk = pi->chunk;

        {
            if ((pi->chunk)->flags & 0x0002u) {
                if ((pi->chunk)->flags & 0x0001u) {
                    if (!_spaces__lockSharedSem(pi->chunk))
                        return SPACES_CHUNK_CORRUPT;
                } else { {
                        if (!(pthread_mutex_lock(&(&((pi->chunk)->mutex))->m) == 0 && ++(&((pi->chunk)->mutex))->count))
                            return SPACES_CHUNK_CORRUPT;
                        if ((pi->chunk)->mutex.count == 1) {
                            if (((pi->chunk)->flags & 0x0002u)) { {
                                    int i___ = 2;
                                    int k___ = 0;
                                    while (!((((pi->chunk)->lock) && spaces__test_and_clear(&(pi->chunk)->lock)))) {;
                                        if (i___-- == 0) {
                                            spaces__smpYield(k___++);
                                            i___ = 2;
                                        }
                                    }
                            }
                            };
                        }
                };
                }
            }
        };

        {
            _spaces__setChunkInfo((pi->chunk), pi);
        }

        {
            if ((pi->chunk)->flags & 0x0002u) {
                if ((pi->chunk)->flags & 0x0001u)
                    _spaces__unlockSharedSem(pi->chunk);
                else { {
                        if ((pi->chunk)->mutex.count == 1) { {
                                if (((pi->chunk)->flags & 0x0002u) && !(pi->chunk)->locktid) {
                                    if (!spaces__preForkLock) { {
                                            if ((pi->chunk)->smpFreeQueue)
                                                spaces__smpFlushQueue(pi->chunk);
                                    };
                                    }
                                    ((pi->chunk)->lock = 1);
                                }
                        };
                        }
                        (--(&((pi->chunk)->mutex))->count, pthread_mutex_unlock(&(&((pi->chunk)->mutex))->m));
                };
                }
            }
        };
    }

    return result;
};

static void _spaces__setChunkInfo(Chunk * chunk, SpacesChunkInfo * pi)
{
    PageHeader *rover;
    TaskRecord *taskRec;

    pi->chunk = chunk;
    pi->type = (SpacesBlockType) 0;
    if (chunk->rovers[((PageType) 0)]
        || chunk->rovers[((PageType) 4)]
        || chunk->rovers[((PageType) 5)])
        pi->type |= SPACES_BLOCK_VAR_FIXED;

    if (chunk->rovers[((PageType) 1)])
        pi->type |= SPACES_BLOCK_FIXED;

    rover = chunk->rovers[((PageType) 3)];
    while (rover && (pi->type & (SPACES_BLOCK_VAR_FIXED | SPACES_BLOCK_VAR_MOVEABLE))
           != (SPACES_BLOCK_VAR_FIXED | SPACES_BLOCK_VAR_MOVEABLE)) {
        switch (rover->page->hdr.ext.type) {

        case ((PageType) 0):
            pi->type |= SPACES_BLOCK_VAR_FIXED;
            break;
        }
        if ((rover = rover->next) == chunk->rovers[((PageType) 3)])
            break;
    }

    pi->blockSizeFS = chunk->blockSizeFS;
    pi->smallBlockSize = (unsigned short) chunk->smallSize;
    pi->pageSize = chunk->pageSize;
    pi->floor = chunk->floor;
    pi->ceiling = chunk->ceiling;
    pi->flags = chunk->flags;

    {
        if (!spaces__createAndEnterMutex(&spaces__mutexGlobal))
            return;
    };

    if (chunk->flags & 0x0001u)
        taskRec = (&_spaces__TaskRecord);
    else
        taskRec = chunk->task.private_.taskRec;
    if (taskRec)
        pi->errorFn = taskRec->errorFn;

    {
        if (!spaces__preInitThreads)
            (--(&spaces__mutexGlobal)->count, pthread_mutex_unlock(&(&spaces__mutexGlobal)->m));
    };
};

static void spaces__insertPageHeader(Chunk * chunk, PageHeader * pageHdr, PageType type);
static void spaces__removePageHeader(Chunk * chunk, PageHeader * pageHdr, PageType type);
static void spaces__preFreePage(Chunk * chunk, Page * page, PageType type);
static Bool spaces__initPage(Chunk * chunk, Page * page, PageHeader * pageHeader, Bool bNewPage,
                             PageType type, size_t size, unsigned flags, unsigned index);
static Page *_spaces__newPage(Chunk *, PageType, size_t, unsigned, unsigned);

typedef enum {
    SPACESISHRINKCOMPACT = 1,
    SPACESISHRINKFREEBYTES = 2
} MSHRINKTYPE;

static size_t _spaces__shrinkChunk(Chunk *, MSHRINKTYPE);

static PageSize _spaces__initPageExternal(Page *, unsigned);
static void _spaces__freeExternal(void *, Bool * pageDeleted);
static Bool _spaces__resizeExternal(Page *, void **, size_t, unsigned);

static PageSize _spaces__initPageFS(Chunk *, Page *, PageSize);
static void _spaces__initLinksFS(Page *, PageSize, PageSize);
static void *_spaces__allocFS(Chunk *);
static void _spaces__freeFS(void *, Bool * pageDeleted);

static PageSize spaces__initPageSmall(Page *, size_t);
static void *spaces__allocSmall(Chunk * chunk, unsigned flags, PageSize size);
static void spaces__freeSmall(void *, Bool * pageDeleted);

static PageSize spaces__initPageSmall2(Page *, size_t, unsigned index);
extern void *spaces__allocSmall2(Chunk * chunk, unsigned flags, PageSize size);
static void spaces__freeSmall2(void *, Bool * pageDeleted);
static void spaces__freeNull(void *mem, Bool * pageDeleted);

static char spaces__copyright[] __attribute__((unused))
    = "Copyright (C) 2021 Notaceon Inc.  All Rights Reserved.";

FREEFN _spaces__freeFns[((PageType) 7)] = {
    _spaces__freeVar,
    _spaces__freeFS,
    _spaces__freeVar,
    _spaces__freeExternal,
    spaces__freeNull,
    spaces__freeSmall2,
    spaces__freeNull
};

typedef void *(*SPACESISMALLFN)
 (struct _Chunk * chunk, unsigned flags, PageSize size);

SPACESISMALLFN spaces__smallFns[SPACES_SMALL_V5 + 1] = {
    0,
    spaces__allocSmall,
    spaces__allocSmall2
};

PageSize(*_spaces__compactChunkFn) (struct _Chunk *, PageSize) = 0;
PageSize(*_spaces__compactPageFn) (Page *, PageSize, FreeBlock *) = 0;

size_t spaces_chunk_shrink(Chunk * chunk)
{
    size_t result = 0;

    {
        if (!(chunk)) {
            (chunk) = (spaces_default_chunk = spaces_init_default_chunk());
        }
    };
    {
        if ((chunk)->flags & 0x8000u) {
            ThreadID tid_ = pthread_self();
            ThreadLocalChunk *tlp_ = &spaces__threadLocalChunks[tid_ % 997];
            if (tlp_->tid == tid_)
                (chunk) = tlp_->chunk;
        };
    };

    {
        if ((chunk)->smpParent)
            (chunk) = (chunk)->smpParent;
        do { {
                if ((chunk)->flags & 0x0002u) {
                    if ((chunk)->flags & 0x0001u) {
                        if (!_spaces__lockSharedSem(chunk))
                            return (size_t) (-1);
                    } else { {
                            if (!(pthread_mutex_lock(&(&((chunk)->mutex))->m) == 0 && ++(&((chunk)->mutex))->count))
                                return (size_t) (-1);
                            if ((chunk)->mutex.count == 1) {
                                if (((chunk)->flags & 0x0002u)) { {
                                        int i___ = 2;
                                        int k___ = 0;
                                        while (!((((chunk)->lock) && spaces__test_and_clear(&(chunk)->lock)))) {;
                                            if (i___-- == 0) {
                                                spaces__smpYield(k___++);
                                                i___ = 2;
                                            }
                                        }
                                }
                                };
                            }
                    };
                    }
                }
        };
        result += _spaces__shrinkChunk(chunk, SPACESISHRINKCOMPACT);
        {
            if ((chunk)->flags & 0x0002u) {
                if ((chunk)->flags & 0x0001u)
                    _spaces__unlockSharedSem(chunk);
                else { {
                        if ((chunk)->mutex.count == 1) { {
                                if (((chunk)->flags & 0x0002u) && !(chunk)->locktid) {
                                    if (!spaces__preForkLock) { {
                                            if ((chunk)->smpFreeQueue)
                                                spaces__smpFlushQueue(chunk);
                                    };
                                    }
                                    ((chunk)->lock = 1);
                                }
                        };
                        }
                        (--(&((chunk)->mutex))->count, pthread_mutex_unlock(&(&((chunk)->mutex))->m));
                };
                }
            }
        };
        } while (((chunk) = (chunk)->smpNextChunk) != 0 && (chunk) != (chunk)->smpParent);
    }
    return result;
};

static size_t _spaces__shrinkChunk(Chunk * chunk, MSHRINKTYPE shrinkType)
{
    size_t oldSize = ((chunk)->pageTotal);
    PageType i;
    PageHeader *rover, *next, *doneRover;

    for (i = 0; i < ((PageType) 7); i++)
        if ((rover = chunk->rovers[i]) != 0 && i != ((PageType) 3)
            && i != ((PageType) 4)) {

            doneRover = 0;
            do {
                next = rover->next;
                if (rover->page->allocCount == 0) {
                    Page *page = rover->page;
                    Bool bDeleted;

                    bDeleted = spaces__deletePage(page, shrinkType);
                    if (bDeleted) {
                        if (rover == next) {
                            next = 0;
                        }
                    } else
                        goto floorReached;
                } else if (!doneRover)
                    doneRover = rover;
            }
            while ((rover = next) != doneRover);
        }

    if (_spaces__compactChunkFn)
        _spaces__compactChunkFn(chunk, (0x7fffffffffffffffL * 2UL + 1UL)
            );

  floorReached:
    return oldSize - ((chunk)->pageTotal);
};

size_t spaces_chunk_preallocate(Chunk * chunk, size_t bytes, SpacesBlockType type)
{
    PageType pageType;
    size_t bytesAdded = 0;

    {
        if (!(chunk)) {
            (chunk) = (spaces_default_chunk = spaces_init_default_chunk());
        }
    };
    {
        if ((chunk)->flags & 0x8000u) {
            ThreadID tid_ = pthread_self();
            ThreadLocalChunk *tlp_ = &spaces__threadLocalChunks[tid_ % 997];
            if (tlp_->tid == tid_)
                (chunk) = tlp_->chunk;
        };
    };

    spaces_malloc_linked = 1;

    switch (type) {
    case SPACES_BLOCK_FIXED:
        pageType = ((PageType) 1);
        if (chunk->blockSizeFS == 0) {
            _spaces__invokeErrorHandler1(chunk, SPACES_ERR_ALLOC_ZERO);
            return (size_t) (-1);
        }
        break;
    default:
        pageType = ((PageType) 6);
        break;
    }

    if ((chunk)->flags & (0x0002u | 0x00010000u))
        ((chunk) = spaces__getProcessorChunk(chunk));

    bytesAdded = spaces__preallocBytes(chunk, pageType, bytes);

    {
        if (((chunk)->flags & 0x0002u) && !(chunk)->locktid) {
            if (!spaces__preForkLock) { {
                    if ((chunk)->smpFreeQueue)
                        spaces__smpFlushQueue(chunk);
            };
            }
            ((chunk)->lock = 1);
        }
    };

    return bytesAdded;
};

size_t spaces__preallocBytes(Chunk * chunk, PageType type, size_t bytes)
{
    size_t bytesAdded = 0;

    bytes =
        (((unsigned long) ((unsigned long) ((unsigned long) ((bytes)) + (unsigned long) ((0x10000) - 1u)) &
                           ((unsigned long) (~((unsigned long) ((0x10000) - 1u)))))) -
         ((PageSize)
          ((PageSize) ((PageSize) (sizeof(Area)) + (PageSize) ((sizeof(double)) - 1u)) &
           ((PageSize) (~((PageSize) ((sizeof(double)) - 1u)))))));

    while (bytesAdded < bytes) {
        Page *page = _spaces__newPage(chunk, type, chunk->pageSize, 0, 0);

        if (!page)
            break;

        bytesAdded += _spaces__sysSize(page);
    }

    return bytesAdded;
};

void spaces__adjustThreshold(size_t *threshold, size_t def, size_t cmp, unsigned pwr)
{
    (void) threshold;
    (void) def;
    (void) cmp;
    (void) pwr;
    cmp >>= pwr;

    if (*threshold > (cmp + cmp)) {

        if (*threshold <= def)
            *threshold = def;
        else
            (*threshold) >>= 1;
    } else if (*threshold < cmp)
        *threshold <<= 1;
};

Bool _spaces__initPageHeaders(Chunk * chunk)
{
    register PageHeader *newHeader = 0, *freeList, *lastHeader = 0;
    size_t size;
    size_t oldSize = 0;

    PageHdrStorage *headerStorage = 0;
    if (chunk->pages[0].page) {
    } else {
        size = _spaces__sysSize(chunk);
        newHeader = &chunk->pages[0];
        chunk->pageTotal -=
            ((unsigned long) ((unsigned long) ((unsigned long) ((size)) + (unsigned long) ((0x00010000lu) - 1u)) &
                              ((unsigned long) (~((unsigned long) ((0x00010000lu) - 1u))))));
    }
    if (newHeader) {
        size = _spaces__sysSize(chunk);
        lastHeader = &chunk->pages[0] + ((int) (((size) - (sizeof(Chunk))) / sizeof(PageHeader) + 1)) - 1;
    } else {

        oldSize = 0;
        size =
            (0x00010000lu -
             ((PageSize)
              ((PageSize) ((PageSize) (sizeof(Area)) + (PageSize) ((sizeof(double)) - 1u)) &
               ((PageSize) (~((PageSize) ((sizeof(double)) - 1u)))))));

        while ((headerStorage = (PageHdrStorage *)
                _spaces__sysAllocChunk(chunk, size, chunk->flags | 0x1000u | 0x0080u)) == 0) {
            Bool bRetry;

            {
                if (((chunk)->flags & 0x0002u) && !(chunk)->locktid) {
                    if (!spaces__preForkLock) { {
                            if ((chunk)->smpFreeQueue)
                                spaces__smpFlushQueue(chunk);
                    };
                    }
                    ((chunk)->lock = 1);
                }
            };
            bRetry = _spaces__invokeErrorHandler1(chunk, SPACES_ERR_OUT_OF_MEMORY);
            if (((chunk)->flags & 0x0002u)) { {
                    int i___ = 2;
                    int k___ = 0;
                    while (!((((chunk)->lock) && spaces__test_and_clear(&(chunk)->lock)))) {;
                        if (i___-- == 0) {
                            spaces__smpYield(k___++);
                            i___ = 2;
                        }
                    }
            }
            };

            if (!bRetry)
                return chunk->freePages != 0;

        }

        headerStorage->next = chunk->extraPages;
        chunk->extraPages = headerStorage;
        newHeader = &headerStorage->pages[0];
    }
    if (!lastHeader) {
        chunk->pageTotal -=
            ((unsigned long) ((unsigned long) ((unsigned long) ((oldSize)) + (unsigned long) ((0x00010000lu) - 1u)) &
                              ((unsigned long) (~((unsigned long) ((0x00010000lu) - 1u))))));
        size = _spaces__sysSize(headerStorage);
        lastHeader = &headerStorage->pages[0] +
            ((int) (((size) - (sizeof(PageHdrStorage))) / sizeof(PageHeader) + 1)) - 1;
    }

    chunk->pageTotal +=
        ((unsigned long) ((unsigned long) ((unsigned long) ((size)) + (unsigned long) ((0x00010000lu) - 1u)) &
                          ((unsigned long) (~((unsigned long) ((0x00010000lu) - 1u))))));

    freeList = chunk->freePages;

    do {
        newHeader->next = freeList;
        ((newHeader)->moveableFlags &= ~0x7000, (newHeader)->moveableFlags |= ((((PageType) 7)) << 12));
        freeList = newHeader;
    }

    while (newHeader++ < lastHeader);

    chunk->freePages = freeList;

    return 1;
};

PageHeader *spaces__allocPageHeader(Chunk * chunk)
{
    PageHeader *pageHeader;

    if (!chunk->freePages)
        if (!_spaces__initPageHeaders(chunk))
            return 0;

    pageHeader = chunk->freePages;
    chunk->freePages = pageHeader->next;

    pageHeader->page = (Page *) ((unsigned long) 0 - 1);

    return pageHeader;
};

void spaces__freePageHeader(Chunk * chunk, PageHeader * pgHdr)
{

    pgHdr->next = chunk->freePages;
    chunk->freePages = pgHdr;
};

static void spaces__insertPageHeader(Chunk * chunk, PageHeader * pageHdr, PageType type)
{
    PageHeader *rover = chunk->rovers[type];

    if (rover) {

        {
            (pageHdr)->prev = (rover);
            (pageHdr)->next = (rover)->next;
            (rover)->next->prev = (pageHdr);
            (rover)->next = (pageHdr);
        };
    } else {

        pageHdr->next = pageHdr->prev = pageHdr;
    }

    chunk->rovers[type] = pageHdr;
};

static void spaces__removePageHeader(Chunk * chunk, PageHeader * pageHdr, PageType type)
{

    if (pageHdr == pageHdr->next) {

        chunk->rovers[type] = 0;
    } else {
        if (chunk->rovers[type] == pageHdr)
            chunk->rovers[type] = pageHdr->next;
        {
            (pageHdr)->prev->next = (pageHdr)->next;
            (pageHdr)->next->prev = (pageHdr)->prev;
        };
    }
};

static Bool spaces__initPage(Chunk * chunk, Page * page, PageHeader * pageHeader, Bool bNewPage,
                             PageType type, size_t size, unsigned flags, unsigned index)
{
    PageSize largestFree;
    Bool bResult = 0;


    ((page)->flagsAndSignature = (PageType) (((PageType) 0xCAD0) | (type)));
    page->chunk = chunk;
    page->allocCount = 0;

    switch (type) {
    case ((PageType) 6):
        largestFree = (PageSize) size;
        break;
    case ((PageType) 5):
        largestFree = spaces__initPageSmall2(page, size, index);
        break;

    case ((PageType) 4):
        largestFree = spaces__initPageSmall(page, size);
        break;

    case ((PageType) 1):
        largestFree = _spaces__initPageFS(chunk, page, (PageSize) size);
        break;
    case ((PageType) 3):
        largestFree = _spaces__initPageExternal(page, flags);
        break;
    default:
        largestFree = _spaces__initPageVariable(page, (PageSize) size);
        break;
    }

    if (!pageHeader)
        pageHeader = spaces__allocPageHeader(chunk);

    if (pageHeader) {
        ((pageHeader)->moveableFlags &= ~0x7000, (pageHeader)->moveableFlags |= ((type) << 12));

        page->pageHeader = pageHeader;
        pageHeader->page = page;
        pageHeader->largestFree = largestFree;
        ((pageHeader)->moveableFlags = ((0x7fffffffffffffffL * 2UL + 1UL)
                                        - ((0x7fffffffffffffffL * 2UL + 1UL)
                                           >> 1)), ((pageHeader)->moveableFlags &=
                                                    ~0x7000, (pageHeader)->moveableFlags |= ((type) << 12)));

        spaces__insertPageHeader(chunk, pageHeader, type);

        if (type == ((PageType) 5)) {
            SmallFreeList *head = &chunk->smallFreeLists[index];

            if (head->page) {

                Page *headPage = head->page;
                {
                    (page)->hdr.fs.prev = (headPage);
                    (page)->hdr.fs.next = (headPage)->hdr.fs.next;
                    (headPage)->hdr.fs.next->hdr.fs.prev = (page);
                    (headPage)->hdr.fs.next = (page);
                };
            } else
                page->hdr.fs.next = page->hdr.fs.prev = page;

            head->page = page;
        }

        if (bNewPage) {
            chunk->pageTotal +=
                ((unsigned long) ((unsigned long) ((unsigned long) ((size)) + (unsigned long) ((0x00010000lu) - 1u)) &
                                  ((unsigned long) (~((unsigned long) ((0x00010000lu) - 1u))))));

            if (type == ((PageType) 6))
                chunk->totalFree +=
                    ((unsigned long) ((unsigned long) ((unsigned long) ((size)) + (unsigned long) ((0x00010000lu) - 1u))
                                      & ((unsigned long) (~((unsigned long) ((0x00010000lu) - 1u))))));

        }

        bResult = 1;
    }

    return bResult;
};

static Page *_spaces__newPage(Chunk * chunk, PageType type, size_t size, unsigned flags, unsigned index)
{
    PageHeader *pageHeader = 0;
    Page *page = 0;
    unsigned sysFlags;
    Bool bNewPage = 0;
    size_t freeSize = 0;

    if (type != ((PageType) 6)
        && chunk->rovers[((PageType) 6)]
        && ((pageHeader = chunk->rovers[((PageType) 6)]->next),
            (page = pageHeader->page), (freeSize = _spaces__sysSize(page)), (type == ((PageType) 5)
                                                                             || size <= freeSize))) {

        size = freeSize;

        spaces__removePageHeader(chunk, pageHeader, ((PageType) 6));

        if (flags & 0x0001u) {
            memset(((FSBlock
                     *) (((char
                           *) ((Block *) ((char *) (page) +
                                          (((PageSize)
                                            ((PageSize)
                                             ((PageSize) (sizeof(Page) + (0)) +
                                              (PageSize) ((sizeof(double)) -
                                                          1u)) &
                                             ((PageSize) (~((PageSize) ((sizeof(double)) - 1u)))))))))) - 0)), 0,
                   size -
                   ((PageSize)
                    ((PageSize) ((PageSize) (sizeof(Page) + (0)) + (PageSize) ((sizeof(double)) - 1u)) &
                     ((PageSize) (~((PageSize) ((sizeof(double)) - 1u)))))));
        }

        chunk->totalFree -=
            ((unsigned long) ((unsigned long) ((unsigned long) ((size)) + (unsigned long) ((0x00010000lu) - 1u)) &
                              ((unsigned long) (~((unsigned long) ((0x00010000lu) - 1u))))));

    } else {
        if (chunk->pageTotal +
            ((size_t)
             ((size_t) ((size_t) (size) + (size_t) ((0x00010000lu) - 1u)) &
              ((size_t) (~((size_t) ((0x00010000lu) - 1u))))))
            > chunk->ceiling) {

            _spaces__invokeErrorHandler1(chunk, SPACES_ERR_EXCEEDED_CEILING);
            return 0;
        }

        {
            if (((chunk)->flags & 0x0002u) && !(chunk)->locktid) {
                if (!spaces__preForkLock) { {
                        if ((chunk)->smpFreeQueue)
                            spaces__smpFlushQueue(chunk);
                };
                }
                ((chunk)->lock = 1);
            }
        };

        if (type == ((PageType) 3))
            sysFlags = 0x2000u | ((flags & 0x0001u) ? 0x0100u : 0);
        else if (type == ((PageType) 6))
            sysFlags = 0x00100000u;
        else
            sysFlags = 0x1000u;

        page = spaces__sysAllocPageCached(chunk, size, chunk->flags | sysFlags);

        if (((chunk)->flags & 0x0002u)) { {
                int i___ = 2;
                int k___ = 0;
                while (!((((chunk)->lock) && spaces__test_and_clear(&(chunk)->lock)))) {;
                    if (i___-- == 0) {
                        spaces__smpYield(k___++);
                        i___ = 2;
                    }
                }
        }
        };
        if (!page)
            return 0;

        size = _spaces__sysSize(page);
        pageHeader = 0;
        bNewPage = 1;
    }

    size = _spaces__sysSize(page);

    if (!spaces__initPage(chunk, page, pageHeader, bNewPage, type, size, flags, index)) {
        if (bNewPage)
            spaces__sysFreePageCached(page);
        page = 0;
    }

    return page;
};

static void spaces__preFreePage(Chunk * chunk, Page * page, PageType type)
{
    size_t size = _spaces__sysSize(page);

    spaces__freePageHeader(chunk, page->pageHeader);
    if (type == ((PageType) 6))
        chunk->totalFree -=
            ((unsigned long) ((unsigned long) ((unsigned long) ((size)) + (unsigned long) ((0x00010000lu) - 1u)) &
                              ((unsigned long) (~((unsigned long) ((0x00010000lu) - 1u))))));

    chunk->pageTotal -=
        ((unsigned long) ((unsigned long) ((unsigned long) ((size)) + (unsigned long) ((0x00010000lu) - 1u)) &
                          ((unsigned long) (~((unsigned long) ((0x00010000lu) - 1u))))));
};

Bool spaces__deletePage(Page * page, Bool bCompacting)
{
    Chunk *chunk = page->chunk;
    PageType type = ((PageType) ((page)->flagsAndSignature & ((PageType) 0x000F)));
    Bool bDelete = 0;
    size_t size;
    spaces__removePageHeader(chunk, page->pageHeader, type);

    if (type == ((PageType) 5)) {
        if (page->hdr.fs.next == page) {

            page->chunk->smallFreeLists[page->hdr.fs.index].page = 0;
        } else {
            if (page->chunk->smallFreeLists[page->hdr.fs.index].page == page)
                page->chunk->smallFreeLists[page->hdr.fs.index].page = page->hdr.fs.next;
            {
                (page)->hdr.fs.prev->hdr.fs.next = (page)->hdr.fs.next;
                (page)->hdr.fs.next->hdr.fs.prev = (page)->hdr.fs.prev;
            };
        }
    }

    page->allocCount = 0;
    ((page)->flagsAndSignature = (PageType) (((PageType) 0xCAD0) | (((PageType) 6))));
    ((page->pageHeader)->moveableFlags &= ~0x7000, (page->pageHeader)->moveableFlags |= ((((PageType) 6)) << 12));

    size = _spaces__sysSize(page);

    if (type == ((PageType) 3)
        && size >
        (0x00010000lu -
         ((PageSize)
          ((PageSize) ((PageSize) (sizeof(Area)) + (PageSize) ((sizeof(double)) - 1u)) &
           ((PageSize) (~((PageSize) ((sizeof(double)) - 1u)))))))) {

        bDelete = 1;
    }

    if (bDelete || (bCompacting == SPACESISHRINKCOMPACT && (chunk->pageTotal - size > chunk->floor))
        || (chunk->totalFree + size > chunk->freeBytes)) {
        Bool bUnlockedChunk = 0;

        spaces__preFreePage(chunk, page, type);

        if (!bCompacting) {

            if (chunk->totalFree > chunk->freeBytes)
                _spaces__shrinkChunk(chunk, SPACESISHRINKFREEBYTES);

        }

        spaces__sysFreePageCached(page);

        return bCompacting || bUnlockedChunk;
    } else {

        spaces__insertPageHeader(chunk, page->pageHeader, ((PageType) 6));

        if (type != ((PageType) 6))
            chunk->totalFree +=
                ((unsigned long) ((unsigned long) ((unsigned long) ((size)) + (unsigned long) ((0x00010000lu) - 1u)) &
                                  ((unsigned long) (~((unsigned long) ((0x00010000lu) - 1u))))));

    }

    return 0;
};

static PageSize _spaces__initPageExternal(Page * page, unsigned flags)
{
    page->allocCount = 1;
    page->hdr.ext.type = (unsigned) (flags & ((PageType) 0));
    page->hdr.ext.alignment = 0;

    return 0;
};

void *_spaces__allocExternal(Chunk * chunk, unsigned flags, size_t size)
{
    Page *page;
    size_t shrank = 0;
    size +=
        ((PageSize)
         ((PageSize) ((PageSize) (sizeof(Page) + (0)) + (PageSize) ((sizeof(double)) - 1u)) &
          ((PageSize) (~((PageSize) ((sizeof(double)) - 1u))))));

    do {
        if ((page = _spaces__newPage(chunk, ((PageType) 3), size, flags, 0))
            != 0) {

            return (char *) page +
                ((PageSize)
                 ((PageSize) ((PageSize) (sizeof(Page) + (0)) + (PageSize) ((sizeof(double)) - 1u)) &
                  ((PageSize) (~((PageSize) ((sizeof(double)) - 1u))))));
        }

        shrank = _spaces__shrinkChunk(chunk, SPACESISHRINKCOMPACT);

        if (chunk->pageTotal +
            ((size_t)
             ((size_t) ((size_t) (size) + (size_t) ((0x00010000lu) - 1u)) &
              ((size_t) (~((size_t) ((0x00010000lu) - 1u))))))
            <= chunk->ceiling && !shrank) {

            {
                if (((chunk)->flags & 0x0002u) && !(chunk)->locktid) {
                    if (!spaces__preForkLock) { {
                            if ((chunk)->smpFreeQueue)
                                spaces__smpFlushQueue(chunk);
                    };
                    }
                    ((chunk)->lock = 1);
                }
            };

            if (_spaces__invokeErrorHandler1(chunk, SPACES_ERR_OUT_OF_MEMORY))
                shrank = 1;

            if (((chunk)->flags & 0x0002u)) { {
                    int i___ = 2;
                    int k___ = 0;
                    while (!((((chunk)->lock) && spaces__test_and_clear(&(chunk)->lock)))) {;
                        if (i___-- == 0) {
                            spaces__smpYield(k___++);
                            i___ = 2;
                        }
                    }
            }
            };

            {
                if ((chunk)->smpFreeQueue)
                    spaces__smpFlushQueue(chunk);
            };
        }
    }
    while (shrank);

    return 0;
};

static void _spaces__freeExternal(void *mem, Bool * pageDeleted)
{
    (void) mem;

    *pageDeleted = spaces__deletePage(((Page *) (((unsigned long) (mem) & ((0x7fffffffffffffffL * 2UL + 1UL)
                                                                           - (0x00010000lu - 1))) +
                                                 ((PageSize)
                                                  ((PageSize)
                                                   ((PageSize) (sizeof(Area)) +
                                                    (PageSize) ((sizeof(double)) -
                                                                1u)) &
                                                   ((PageSize) (~((PageSize) ((sizeof(double)) - 1u)))))))), 0);
};

static Bool _spaces__resizeExternal(Page * page, void **dst, size_t size, unsigned flags)
{
    size_t oldSize;
    Page *newPage = 0;
    Chunk *chunk;
    Bool result = 1;
    Bool bMoveable = 0;
    PageHeader *pageHdr = page->pageHeader;

    chunk = page->chunk;
    oldSize = _spaces__sysSize(page);

    size +=
        ((PageSize)
         ((PageSize) ((PageSize) (sizeof(Page) + (0)) + (PageSize) ((sizeof(double)) - 1u)) &
          ((PageSize) (~((PageSize) ((sizeof(double)) - 1u))))));
    flags = chunk->flags | ((flags & 0x0001u) ? 0x0100u : 0)
        | ((flags & 0x0004u) ? 0x0400u : 0);

    if (!bMoveable) {
        if (((chunk)->flags & 0x0002u)) { {
                int i___ = 2;
                int k___ = 0;
                while (!((((chunk)->lock) && spaces__test_and_clear(&(chunk)->lock)))) {;
                    if (i___-- == 0) {
                        spaces__smpYield(k___++);
                        i___ = 2;
                    }
                }
        }
        };
    }

    if (dst) {
        Bool bRetry = 1;

        while (bRetry && (newPage = (Page *)
                          _spaces__sysReallocChunk(chunk, page, size, flags | 0x2000u))
               == 0) {

            if (!bMoveable) {
                if (((chunk)->flags & 0x0002u) && !(chunk)->locktid) {
                    if (!spaces__preForkLock) { {
                            if ((chunk)->smpFreeQueue)
                                spaces__smpFlushQueue(chunk);
                    };
                    }
                    ((chunk)->lock = 1);
                }
            };
            bRetry = _spaces__invokeErrorHandler1(chunk, SPACES_ERR_OUT_OF_MEMORY);
            if (!bMoveable)
                if (((chunk)->flags & 0x0002u)) { {
                        int i___ = 2;
                        int k___ = 0;
                        while (!((((chunk)->lock) && spaces__test_and_clear(&(chunk)->lock)))) {;
                            if (i___-- == 0) {
                                spaces__smpYield(k___++);
                                i___ = 2;
                            }
                        }
                }
                };
        }

        if (!newPage) {
            *dst = 0;
            result = 0;
        }
    } else {

        if (_spaces__sysResizeChunk(chunk, page, size, flags | 0x2000u))
            newPage = page;
        else
            result = 0;
    }

    if (result) {

        if (newPage != page) {
            pageHdr->page = newPage;

            *dst =
                (char *) newPage +
                ((PageSize)
                 ((PageSize) ((PageSize) (sizeof(Page) + (0)) + (PageSize) ((sizeof(double)) - 1u)) &
                  ((PageSize) (~((PageSize) ((sizeof(double)) - 1u))))));
        }

        chunk->pageTotal += _spaces__sysSize(newPage) - oldSize;

    }

    if (!bMoveable) {
        {
            if (((chunk)->flags & 0x0002u) && !(chunk)->locktid) {
                if (!spaces__preForkLock) { {
                        if ((chunk)->smpFreeQueue)
                            spaces__smpFlushQueue(chunk);
                };
                }
                ((chunk)->lock = 1);
            }
        };
    }

    return result;
};

static PageSize _spaces__initPageFS(Chunk * chunk, Page * page, PageSize size)
{
    page->hdr.fs.freeList = 0;
    page->hdr.fs.end =
        (char
         *) ((FSBlock
              *) (((char
                    *) ((Block *) ((char *) (page) +
                                   (((PageSize)
                                     ((PageSize) ((PageSize) (sizeof(Page) + (0)) + (PageSize) ((sizeof(double)) - 1u))
                                      & ((PageSize) (~((PageSize) ((sizeof(double)) - 1u)))))))))) - 0));

    _spaces__initLinksFS(page, (PageSize) (chunk->blockSizeFS + 0), size);

    return 1;
};

static void _spaces__initLinksFS(Page * page, register PageSize blockSize, PageSize size)
{
    register char *pLink;
    char *pFirst, *pLast;

    pFirst = page->hdr.fs.end;
    page->hdr.fs.freeList = (FSBlock *) pFirst;

    size -= (PageSize) (pFirst - (char *) page);
    page->hdr.fs.end = pFirst + (size - (size % blockSize));

    pLast = page->hdr.fs.end - (ptrdiff_t) blockSize;
    for (pLink = pFirst; pLink < pLast; pLink += blockSize) {
        ((FSBlock *) pLink)->next = (FSBlock *) (pLink + blockSize);
    }

    ((FSBlock *) pLink)->next = 0;
};

void *spaces_chunk_alloc_fixed(Chunk * chunk)
{
    void *result;

    {
        if (!(chunk)) {
            (chunk) = (spaces_default_chunk = spaces_init_default_chunk());
        }
    };

    if ((chunk)->flags & (0x0002u | 0x00010000u))
        ((chunk) = spaces__getProcessorChunk(chunk));

    result = _spaces__allocFS(chunk);

    {
        if (((chunk)->flags & 0x0002u) && !(chunk)->locktid) {
            if (!spaces__preForkLock) { {
                    if ((chunk)->smpFreeQueue)
                        spaces__smpFlushQueue(chunk);
            };
            }
            ((chunk)->lock = 1);
        }
    };

    return result;
};

static void *_spaces__allocFS(Chunk * chunk)
{
    register PageHeader *rover = chunk->rovers[((PageType) 1)];
    PageHeader *savedRover = rover;

    if (!rover)
        goto addPage;

    while (!rover->largestFree) {
      skipTest:
        if ((rover = rover->next) == savedRover) {
            PageSize size;
          addPage:
            if (chunk->blockSizeFS == 0) {
                _spaces__invokeErrorHandler1(chunk, SPACES_ERR_ALLOC_ZERO);
                return 0;
            }

            size = chunk->pageSize;

            while (!_spaces__newPage(chunk, ((PageType) 1), size, 0, 0)) {
                Bool bRetry;

                if (chunk->pageTotal + size > chunk->ceiling)
                    return 0;

                {
                    if (((chunk)->flags & 0x0002u) && !(chunk)->locktid) {
                        if (!spaces__preForkLock) { {
                                if ((chunk)->smpFreeQueue)
                                    spaces__smpFlushQueue(chunk);
                        };
                        }
                        ((chunk)->lock = 1);
                    }
                };
                bRetry = _spaces__invokeErrorHandler1(chunk, SPACES_ERR_OUT_OF_MEMORY);
                if (((chunk)->flags & 0x0002u)) { {
                        int i___ = 2;
                        int k___ = 0;
                        while (!((((chunk)->lock) && spaces__test_and_clear(&(chunk)->lock)))) {;
                            if (i___-- == 0) {
                                spaces__smpYield(k___++);
                                i___ = 2;
                            }
                        }
                }
                };

                if (!bRetry)
                    return 0;

            }

            rover = chunk->rovers[((PageType) 1)];
            savedRover = rover->next;
        }
    }

    {
        Page *page;
        FSBlock *result = 0;
        FSBlock *block;

        page = rover->page;
        if ((block = page->hdr.fs.freeList) != 0) {
            page->hdr.fs.freeList = block->next;
            page->allocCount++;
            result = block;
        }

        if (block) {
            chunk->rovers[((PageType) 1)] = rover;

            return (char *) result + 0;
        } else {
            rover->largestFree = 0;
            goto skipTest;
        }
    }
};

Bool spaces_chunk_free_fixed(void *mem)
{
    {
    };

    {
        Bool pageDeleted = 0;

        Chunk *p = ((Page *) (((unsigned long) (mem) & ((0x7fffffffffffffffL * 2UL + 1UL)
                                                        - (0x00010000lu - 1))) +
                              ((PageSize)
                               ((PageSize) ((PageSize) (sizeof(Area)) + (PageSize) ((sizeof(double)) - 1u)) &
                                ((PageSize) (~((PageSize) ((sizeof(double)) - 1u))))))))->chunk, *chunk = p;

        {
            if (((chunk)->flags & 0x0002u) && spaces__smpEnqueueFree(p, mem))
                return 1;
        };

        {
            Page *page = ((Page *) (((unsigned long) (mem) & ((0x7fffffffffffffffL * 2UL + 1UL)
                                                              - (0x00010000lu - 1))) +
                                    ((PageSize)
                                     ((PageSize) ((PageSize) (sizeof(Area)) + (PageSize) ((sizeof(double)) - 1u)) &
                                      ((PageSize) (~((PageSize) ((sizeof(double)) - 1u))))))));
            if (page->hdr.fs.freeList == 0)
                page->pageHeader->largestFree = 1;
            ((FSBlock *) ((char *) (mem) - 0))->next = page->hdr.fs.freeList;
            page->hdr.fs.freeList = ((FSBlock *) ((char *) (mem) - 0));
            if (--page->allocCount == 0) {;
                *&pageDeleted = spaces__deletePage(page, 0);
            }
        };

        if (!pageDeleted) {
            {
                if (((chunk)->flags & 0x0002u) && !(chunk)->locktid) {
                    if (!spaces__preForkLock) { {
                            if ((chunk)->smpFreeQueue)
                                spaces__smpFlushQueue(chunk);
                    };
                    }
                    ((chunk)->lock = 1);
                }
            };
        };
    }

    return 1;
};

static void _spaces__freeFS(void *mem, Bool * pageDeleted)
{
    {
        Page *page = ((Page *) (((unsigned long) (mem) & ((0x7fffffffffffffffL * 2UL + 1UL)
                                                          - (0x00010000lu - 1))) +
                                ((PageSize)
                                 ((PageSize) ((PageSize) (sizeof(Area)) + (PageSize) ((sizeof(double)) - 1u)) &
                                  ((PageSize) (~((PageSize) ((sizeof(double)) - 1u))))))));
        if (page->hdr.fs.freeList == 0)
            page->pageHeader->largestFree = 1;
        ((FSBlock *) ((char *) (mem) - 0))->next = page->hdr.fs.freeList;
        page->hdr.fs.freeList = ((FSBlock *) ((char *) (mem) - 0));
        if (--page->allocCount == 0) {;
            *pageDeleted = spaces__deletePage(page, 0);
        }
    };
};

PageSize _spaces__initPageVariable(Page * page, PageSize size)
{
    FreeBlock *firstBlock =
        (FreeBlock
         *) ((Block
              *) (((char
                    *) ((Block *) ((char *) (page) +
                                   (((PageSize)
                                     ((PageSize)
                                      ((PageSize) (sizeof(Page) + (sizeof(Block))) +
                                       (PageSize) ((sizeof(double)) -
                                                   1u)) & ((PageSize) (~((PageSize) ((sizeof(double)) - 1u)))))))))) -
                  sizeof(Block)));

    FreeBlock *freeBlock = (FreeBlock *)
        ((Block *) ((char *) (firstBlock) +
                    ((((PageSize) ((size - (PageSize) ((char *) firstBlock - (char *) page) - sizeof(FreeBlock)))) &
                      ((PageSize) (~((PageSize) (((((sizeof(double)) > (4)) ? (sizeof(double)) : (4))) - 1u))))))));

    ((freeBlock)->sizeAndTags = (PageSize) ((0u) | (((PageSize) 1u)) | (0u)));
    page->hdr.var.rover = firstBlock;
    page->hdr.var.freeList = freeBlock->next = freeBlock->prev = freeBlock;

    page->hdr.var.minBlockSize =
        ((PageSize)
         ((PageSize)
          ((PageSize) ((sizeof(FreeBlock) + sizeof(PageSize))) +
           (PageSize) (((((sizeof(double)) >
                          (4)) ? (sizeof(double)) : (4))) -
                       1u)) &
          ((PageSize) (~((PageSize) (((((sizeof(double)) > (4)) ? (sizeof(double)) : (4))) - 1u))))));

    if (page->hdr.var.minBlockSize < (PageSize) (page->chunk->smallSize / 4))
        page->hdr.var.minBlockSize =
            ((PageSize)
             ((PageSize)
              ((PageSize) ((page->chunk->smallSize / 4)) +
               (PageSize) (((((sizeof(double)) >
                              (4)) ? (sizeof(double)) : (4))) -
                           1u)) &
              ((PageSize) (~((PageSize) (((((sizeof(double)) > (4)) ? (sizeof(double)) : (4))) - 1u))))));

    ((firstBlock)->sizeAndTags =
     (PageSize) (((*((PageSize *) (freeBlock) - 1)) =
                  (PageSize) ((char *) freeBlock - (char *) firstBlock)) | (0) | (((PageSize) 2u))));
    _spaces__insertIntoFreeList(firstBlock, freeBlock);


    return ((firstBlock)->sizeAndTags & ((PageSize) (~3u)));
};

static PageSize spaces__initPageSmall(Page * page, size_t size)
{
    page->hdr.fs.end = (char *) page + size;
    page->hdr.fs.free =
        ((char
          *) ((Block *) ((char *) (page) +
                         (((PageSize)
                           ((PageSize) ((PageSize) (sizeof(Page) + (0 + 1)) + (PageSize) ((sizeof(double)) - 1u)) &
                            ((PageSize) (~((PageSize) ((sizeof(double)) - 1u))))))))));

    return 1;
};

static PageSize spaces__initPageSmall2(Page * page, size_t size, unsigned index)
{
    page->hdr.fs.freeList = 0;

    page->hdr.fs.free =
        ((char
          *) ((FSBlock
               *) (((char
                     *) ((Block *) ((char *) (page) +
                                    (((PageSize)
                                      ((PageSize) ((PageSize) (sizeof(Page) + (0)) + (PageSize) ((sizeof(double)) - 1u))
                                       & ((PageSize) (~((PageSize) ((sizeof(double)) - 1u)))))))))) - 0)));
    page->hdr.fs.end = page->hdr.fs.free + (((char *) page + size - page->hdr.fs.free)
                                            / (((index) << 3) +
                                               ((PageSize)
                                                ((PageSize) ((PageSize) (0) + (PageSize) ((sizeof(double)) - 1u)) &
                                                 ((PageSize) (~((PageSize) ((sizeof(double)) - 1u)))))))) * (((index) << 3) +
         ((PageSize)
          ((PageSize) ((PageSize) (0) + (PageSize) ((sizeof(double)) - 1u)) &
           ((PageSize) (~((PageSize) ((sizeof(double)) - 1u)))))));

    page->hdr.fs.head = 0;

    page->hdr.fs.index = index;

    return 1;
};

void *spaces_chunk_alloc(Chunk * chunk, size_t size, unsigned flags)
{
    void *result;

    {
        if (!(chunk)) {
            (chunk) = (spaces_default_chunk = spaces_init_default_chunk());
        }
    };

    if ((chunk)->flags & (0x0002u | 0x00010000u))
        ((chunk) = spaces__getProcessorChunk(chunk));

    if (size <= chunk->smallSize) {
        result = (spaces__smallFns[(chunk)->allocSmallFn]) (chunk, flags, (PageSize) size);

    } else if (size <= chunk->maxSubAlloc)
        result = _spaces__allocVar(chunk, flags & ~0x0002u, (PageSize) size);
    else
        result = _spaces__allocExternal(chunk, flags & ~0x0002u, size);

    {
        if (((chunk)->flags & 0x0002u) && !(chunk)->locktid) {
            if (!spaces__preForkLock) { {
                    if ((chunk)->smpFreeQueue)
                        spaces__smpFlushQueue(chunk);
            };
            }
            ((chunk)->lock = 1);
        }
    };

    return result;
};

void *spaces_chunk_alloc_aligned(SpacesChunk chunk, size_t size, size_t alignment, unsigned flags)
{
    return spaces_chunk_alloc_aligned_offset(chunk, size, alignment, 0, flags);
};

void *spaces_chunk_alloc_aligned_offset(SpacesChunk chunk, size_t size, size_t alignment, size_t offset, unsigned flags)
{

    void *spaces_chunk_alloc(SpacesChunk, size_t, unsigned);
    void *p, *result = 0;

    {
        if (!(chunk)) {
            (chunk) = (spaces_default_chunk = spaces_init_default_chunk());
        }
    };

    if (spaces__bitcount(alignment) != 1) {
        _spaces__invokeErrorHandler1(chunk, SPACES_ERR_BAD_ALIGNMENT);
        return 0;
    }

    size += sizeof(unsigned long) + alignment + offset - 1ul;

    size = (((size) > (chunk->maxSubAlloc + 1)) ? (size) : (chunk->maxSubAlloc + 1));

    p = spaces_chunk_alloc(chunk, size, flags & ~0x0002u);

    if (p) {
        Page *page = ((Page *) (((unsigned long) (p) & ((0x7fffffffffffffffL * 2UL + 1UL)
                                                        - (0x00010000lu - 1))) +
                                ((PageSize)
                                 ((PageSize) ((PageSize) (sizeof(Area)) + (PageSize) ((sizeof(double)) - 1u)) &
                                  ((PageSize) (~((PageSize) ((sizeof(double)) - 1u))))))));

        result =
            (void
             *) (((unsigned
                   long) ((unsigned long) ((unsigned long) ((unsigned long) p + sizeof(unsigned long)) +
                                           (unsigned long) ((alignment) -
                                                            1u)) & ((unsigned
                                                                     long) (~((unsigned long) ((alignment) - 1u))))))
                 + offset);

        page->hdr.ext.alignment = (char *) result - (char *) p;

        *((unsigned long *) result - 1) = page->hdr.ext.alignment;
    }

    return result;
};

static void *spaces__alignedToPtr(void *mem);
static void *spaces__alignedToPtr(void *mem)
{
    void *p;
    Page *page;
    unsigned long alignment;
    SpacesChunk chunk = 0;

    if (!mem)
        return 0;

    {
        alignment = *((unsigned long *) mem - 1);

        p = (char *) mem - alignment;

        {
        };

        page = ((Page *) (((unsigned long) (p) & ((0x7fffffffffffffffL * 2UL + 1UL)
                                                  - (0x00010000lu - 1))) +
                          ((PageSize)
                           ((PageSize) ((PageSize) (sizeof(Area)) + (PageSize) ((sizeof(double)) - 1u)) &
                            ((PageSize) (~((PageSize) ((sizeof(double)) - 1u))))))));
        chunk = page->chunk;
        {
            if (!(chunk)) {
                (chunk) = (spaces_default_chunk = spaces_init_default_chunk());
            }
        };

        if (alignment != page->hdr.ext.alignment
            || p !=
            (char *) page +
            ((PageSize)
             ((PageSize) ((PageSize) (sizeof(Page) + (0)) + (PageSize) ((sizeof(double)) - 1u)) &
              ((PageSize) (~((PageSize) ((sizeof(double)) - 1u))))))
            || _spaces__sysSize(page) < (((char *) p - (char *) page) + alignment))
            goto badPointer;
    }

    return p;

  badPointer:
    _spaces__invokeErrorHandler1(chunk, SPACES_ERR_BAD_POINTER);

    return 0;
};

int spaces_chunk_free_aligned(void *mem)
{
    Bool spaces_chunk_free(void *);

    if (mem) {
        void *p = spaces__alignedToPtr(mem);

        if (p)
            return spaces_chunk_free(p);
    }

    return 0;
};

void *spaces_chunk_realloc_aligned(void *mem, size_t size, size_t alignment, unsigned flags)
{
    return spaces_chunk_realloc_aligned_offset(mem, size, alignment, 0, flags);
};

void *spaces_chunk_realloc_aligned_offset(void *mem, size_t size, size_t alignment, size_t offset, unsigned flags)
{
    Bool spaces_chunk_free(void *);
    void *p = 0;
    Chunk *chunk;
    void *result;
    Page *page;

    if (mem) {
        p = spaces__alignedToPtr(mem);
        page = ((Page *) (((unsigned long) (p) & ((0x7fffffffffffffffL * 2UL + 1UL)
                                                  - (0x00010000lu - 1))) +
                          ((PageSize)
                           ((PageSize) ((PageSize) (sizeof(Area)) + (PageSize) ((sizeof(double)) - 1u)) &
                            ((PageSize) (~((PageSize) ((sizeof(double)) - 1u))))))));

        chunk = page->chunk;
    } else
        chunk = spaces_default_chunk ? spaces_default_chunk : spaces_init_default_chunk();

    result = spaces_chunk_alloc_aligned_offset(chunk, size, alignment, offset, flags);

    if (p && result) {
        size_t oldSize = spaces_chunk_size_aligned(mem);
        size_t bytesToCopy = (((size) < (oldSize)) ? (size) : (oldSize));

        memcpy(result, mem, bytesToCopy);
        spaces_chunk_free(p);
    }

    return result;
};

size_t spaces_chunk_size_aligned(void *mem)
{
    size_t spaces_chunk_ptr_size(void *);

    void *p = spaces__alignedToPtr(mem);

    if (p)
        return spaces_chunk_ptr_size(p);
    else
        return (size_t) (-1);
};

SpacesPointerStatus spaces_chunk_check_aligned(SpacesChunk chunk, void *mem)
{
    SpacesPointerStatus spaces_chunk_ptr_check(SpacesChunk, void *);
    void *p = spaces__alignedToPtr(mem);

    return spaces_chunk_ptr_check(chunk, p);
};

int spaces__bitcount(size_t val)
{
    int bitcount;

    for (bitcount = 0; val; bitcount++)
        val &= (val - 1);

    return bitcount;
};

static void *spaces__allocSmall(Chunk * chunk, unsigned flags, PageSize size)
{
    Page *page = 0;
    unsigned index;
    FreeSmallBlock **block;

    if (size < sizeof(FreeSmallBlock *))
        size = sizeof(FreeSmallBlock *);

    index =
        (unsigned) (((size) +
                     ((PageSize)
                      ((PageSize) ((PageSize) (0) + (PageSize) ((sizeof(double)) - 1u)) &
                       ((PageSize) (~((PageSize) ((sizeof(double)) - 1u)))))) - 0) >> 3);

    block = &chunk->smallFreeLists[index].block;

    if (*block) {
        FreeSmallBlock *result = *block;
        Page *page = ((Page *) (((unsigned long) (result) & ((0x7fffffffffffffffL * 2UL + 1UL)
                                                             - (0x00010000lu - 1))) +
                                ((PageSize)
                                 ((PageSize) ((PageSize) (sizeof(Area)) + (PageSize) ((sizeof(double)) - 1u)) &
                                  ((PageSize) (~((PageSize) ((sizeof(double)) - 1u))))))));

        *block = result->next;
        page->allocCount++;

        if (flags & 0x0001u)
            memset(result, 0,
                   ((((index) << 3) +
                     ((PageSize)
                      ((PageSize) ((PageSize) (0 + 1) + (PageSize) ((sizeof(double)) - 1u)) &
                       ((PageSize) (~((PageSize) ((sizeof(double)) - 1u))))))) - 0 - 1));

        return result;
    } else {
        char *result;
        PageSize alignedSize =
            (PageSize) (((index) << 3) +
                        ((PageSize)
                         ((PageSize) ((PageSize) (0 + 1) + (PageSize) ((sizeof(double)) - 1u)) &
                          ((PageSize) (~((PageSize) ((sizeof(double)) - 1u)))))));
        register PageHeader *rover;

        if ((rover = chunk->rovers[((PageType) 4)]) == 0
            || (page = rover->page, (PageSize) (page->hdr.fs.end - page->hdr.fs.free)
                < alignedSize)) {

            if (rover && rover->largestFree && page->hdr.fs.free != page->hdr.fs.end) {

                if (page->hdr.fs.end - page->hdr.fs.free
                    >=
                    (ptrdiff_t) (sizeof(FreeSmallBlock *) +
                                 ((PageSize)
                                  ((PageSize) ((PageSize) (0 + 1) + (PageSize) ((sizeof(double)) - 1u)) &
                                   ((PageSize) (~((PageSize) ((sizeof(double)) - 1u)))))))) {
                    unsigned i =
                        (((unsigned) (page->hdr.fs.end - page->hdr.fs.free) -
                          ((PageSize)
                           ((PageSize) ((PageSize) (0 + 1) + (PageSize) ((sizeof(double)) - 1u)) &
                            ((PageSize) (~((PageSize) ((sizeof(double)) - 1u))))))) >> 3);
                    Bool pageDeleted = 0;

                    result = page->hdr.fs.free;
                    (*((unsigned char *) (result) - 0 - 1)) = (unsigned char) i;

                    page->allocCount++;
                    spaces__freeSmall(result, &pageDeleted);

                    page->hdr.fs.free +=
                        (((i) << 3) +
                         ((PageSize)
                          ((PageSize) ((PageSize) (0 + 1) + (PageSize) ((sizeof(double)) - 1u)) &
                           ((PageSize) (~((PageSize) ((sizeof(double)) - 1u)))))));
                }

                rover->largestFree = 0;
            }

            if (!(flags & 0x0010u)
                && _spaces__newPage(chunk, ((PageType) 4),
                                    (0x00010000lu -
                                     ((PageSize)
                                      ((PageSize) ((PageSize) (sizeof(Area)) + (PageSize) ((sizeof(double)) - 1u)) &
                                       ((PageSize) (~((PageSize) ((sizeof(double)) - 1u))))))), 0, 0))
                page = chunk->rovers[((PageType) 4)]->page;
            else
                return _spaces__allocVar(chunk, flags & ~0x0002u, size);
        }

        result = page->hdr.fs.free;
        (*((unsigned char *) (result) - 0 - 1)) = (unsigned char) index;
        page->hdr.fs.free += alignedSize;
        page->allocCount++;

        if (flags & 0x0001u)
            memset(result, 0,
                   ((((index) << 3) +
                     ((PageSize)
                      ((PageSize) ((PageSize) (0 + 1) + (PageSize) ((sizeof(double)) - 1u)) &
                       ((PageSize) (~((PageSize) ((sizeof(double)) - 1u))))))) - 0 - 1));

        return result;
    }
};

static void spaces__freeSmall(void *mem, Bool * pageDeleted)
{
    unsigned index = (*((unsigned char *) (mem) - 0 - 1));
    Page *page = ((Page *) (((unsigned long) (mem) & ((0x7fffffffffffffffL * 2UL + 1UL)
                                                      - (0x00010000lu - 1))) +
                            ((PageSize)
                             ((PageSize) ((PageSize) (sizeof(Area)) + (PageSize) ((sizeof(double)) - 1u)) &
                              ((PageSize) (~((PageSize) ((sizeof(double)) - 1u))))))));
    FreeSmallBlock **block = &page->chunk->smallFreeLists[index].block;

    ((FreeSmallBlock *) mem)->next = *block;
    *block = (FreeSmallBlock *) mem;

    if (--page->allocCount == 0) {
        (void) pageDeleted;

    }
};

int spaces_chunk_set_small_allocator(SpacesChunk chunk, SpacesSmallAllocator type)
{
    switch (type) {
    case SPACES_SMALL_NONE:
        return spaces_chunk_set_small_block_size(chunk, 0);

    case SPACES_SMALL_V3:

        if ((spaces__smallFns[(chunk)->allocSmallFn]) == spaces__allocSmall)
            return spaces_chunk_set_small_block_size(chunk, 512);
        break;

    case SPACES_SMALL_V5:
        if ((spaces__smallFns[(chunk)->allocSmallFn]) == spaces__allocSmall2)
            return spaces_chunk_set_small_block_size(chunk, 512);
        break;

    default:
        return 0;
    }

    {
        if ((chunk)->smpParent)
            (chunk) = (chunk)->smpParent;
        do { {
                if ((chunk)->flags & 0x0002u) {
                    if ((chunk)->flags & 0x0001u) {
                        if (!_spaces__lockSharedSem(chunk))
                            return 0;
                    } else { {
                            if (!(pthread_mutex_lock(&(&((chunk)->mutex))->m) == 0 && ++(&((chunk)->mutex))->count))
                                return 0;
                            if ((chunk)->mutex.count == 1) {
                                if (((chunk)->flags & 0x0002u)) { {
                                        int i___ = 2;
                                        int k___ = 0;
                                        while (!((((chunk)->lock) && spaces__test_and_clear(&(chunk)->lock)))) {;
                                            if (i___-- == 0) {
                                                spaces__smpYield(k___++);
                                                i___ = 2;
                                            }
                                        }
                                }
                                };
                            }
                    };
                    }
                }
        };
        {
            SmallFreeList *head = &chunk->smallFreeLists[0];
            int i =
                (((2048 +
                   ((PageSize)
                    ((PageSize) ((PageSize) (0) + (PageSize) ((sizeof(double)) - 1u)) &
                     ((PageSize) (~((PageSize) ((sizeof(double)) - 1u)))))) - 0) >> 3) + 1);
            while (i--)
                head++->page = 0;
            switch (type) {
            case SPACES_SMALL_V3:
                chunk->allocSmallFn = SPACES_SMALL_V3;
                _spaces__freeFns[((PageType) 4)] = spaces__freeSmall;
                _spaces__freeFns[((PageType) 5)] = spaces__freeNull;
                break;
            case SPACES_SMALL_V5:
                chunk->allocSmallFn = SPACES_SMALL_V5;
                _spaces__freeFns[((PageType) 4)] = spaces__freeNull;
                _spaces__freeFns[((PageType) 5)] = spaces__freeSmall2;
                break;
            default:
                break;
            }
        }
        {
            if ((chunk)->flags & 0x0002u) {
                if ((chunk)->flags & 0x0001u)
                    _spaces__unlockSharedSem(chunk);
                else { {
                        if ((chunk)->mutex.count == 1) { {
                                if (((chunk)->flags & 0x0002u) && !(chunk)->locktid) {
                                    if (!spaces__preForkLock) { {
                                            if ((chunk)->smpFreeQueue)
                                                spaces__smpFlushQueue(chunk);
                                    };
                                    }
                                    ((chunk)->lock = 1);
                                }
                        };
                        }
                        (--(&((chunk)->mutex))->count, pthread_mutex_unlock(&(&((chunk)->mutex))->m));
                };
                }
            }
        };
        } while (((chunk) = (chunk)->smpNextChunk) != 0 && (chunk) != (chunk)->smpParent);
    }
    return 1;

};

static void spaces__freeNull(void *mem, Bool * pageDeleted)
{
    (void) mem;
    (void) pageDeleted;
};

void *spaces__allocSmall2(Chunk * chunk, unsigned flags, PageSize size)
{
    Page *page, *savedRover, *resizePage = 0;
    unsigned index;
    SmallFreeList *head;

    index =
        (((((PageSize)
            ((PageSize) ((PageSize) (size) + (PageSize) ((sizeof(double)) - 1u)) &
             ((PageSize) (~((PageSize) ((sizeof(double)) - 1u))))))) + ((PageSize) ((PageSize) ((PageSize) (0) +
                                                                                                (PageSize) ((sizeof
                                                                                                             (double)) -
                                                                                                            1u)) &
                                                                                    ((PageSize)
                                                                                     (~
                                                                                      ((PageSize)
                                                                                       ((sizeof(double)) - 1u)))))) -
          0) >> 3);

    for (;;) {
        head = &chunk->smallFreeLists[index];

        if ((page = head->page) != 0) {
            savedRover = head->page;

            do {
                FSBlock *block;
                if ((block = page->hdr.fs.freeList) != 0)
                    page->hdr.fs.freeList = block->next;
                else if (page->hdr.fs.free < page->hdr.fs.end) {
                    block = (FSBlock *) page->hdr.fs.free;
                    page->hdr.fs.free +=
                        (((index) << 3) +
                         ((PageSize)
                          ((PageSize) ((PageSize) (0) + (PageSize) ((sizeof(double)) - 1u)) &
                           ((PageSize) (~((PageSize) ((sizeof(double)) - 1u)))))));
                } else {
                    (void) resizePage;

                    {

                        if (page != savedRover) {
                            {
                                (page)->hdr.fs.prev->hdr.fs.next = (page)->hdr.fs.next;
                                (page)->hdr.fs.next->hdr.fs.prev = (page)->hdr.fs.prev;
                            };
                            page->hdr.fs.head = head;
                        }
                    }

                    continue;
                }

                head->page = page;

                page->allocCount++;



                if (flags & 0x0001u)
                    memset((char *) block + 0,
                           0,
                           ((((index) << 3) +
                             ((PageSize)
                              ((PageSize) ((PageSize) (0) + (PageSize) ((sizeof(double)) - 1u)) &
                               ((PageSize) (~((PageSize) ((sizeof(double)) - 1u))))))) - 0));

                return (char *) block + 0;
            }
            while ((page = page->hdr.fs.next) != savedRover);
        }

        if (index == 0) {
            index++;
            continue;
        }
        if ((flags & 0x0010u)
            || (page = _spaces__newPage(chunk, ((PageType) 5), chunk->minPageSize, 0, index))
            == 0)
            return _spaces__allocVar(chunk, flags & ~0x0002u, size);
    }
};

static void spaces__freeSmall2(void *mem, Bool * pageDeleted)
{

    {
        Page *page = ((Page *) (((unsigned long) (mem) & ((0x7fffffffffffffffL * 2UL + 1UL)
                                                          - (0x00010000lu - 1))) +
                                ((PageSize)
                                 ((PageSize) ((PageSize) (sizeof(Area)) + (PageSize) ((sizeof(double)) - 1u)) &
                                  ((PageSize) (~((PageSize) ((sizeof(double)) - 1u))))))));
        if (page->hdr.fs.head) {
            if (page->hdr.fs.head->page) { {
                    (page)->hdr.fs.prev = (page->hdr.fs.head->page);
                    (page)->hdr.fs.next = (page->hdr.fs.head->page)->hdr.fs.next;
                    (page->hdr.fs.head->page)->hdr.fs.next->hdr.fs.prev = (page);
                    (page->hdr.fs.head->page)->hdr.fs.next = (page);
            };
            } else {
                page->hdr.fs.next = page->hdr.fs.prev = page;
                page->hdr.fs.head->page = page;
            }
            page->hdr.fs.head = 0;
        }
        ((FSBlock *) ((char *) (mem) - 0))->next = page->hdr.fs.freeList;
        page->hdr.fs.freeList = ((FSBlock *) ((char *) (mem) - 0));
        if (--page->allocCount == 0) {;
            *pageDeleted = spaces__deletePage(page, 0);
        }
    }
};

void *_spaces__allocVar(Chunk * chunk, unsigned flags, register PageSize size)
{
    PageType type;
    register PageHeader *rover;
    PageHeader *savedRover;

    type = (PageType) (flags & 0x0002u);

    size =
        ((PageSize)
         ((PageSize)
          ((PageSize) ((size + sizeof(Block))) +
           (PageSize) (((((sizeof(double)) >
                          (4)) ? (sizeof(double)) : (4))) -
                       1u)) &
          ((PageSize) (~((PageSize) (((((sizeof(double)) > (4)) ? (sizeof(double)) : (4))) - 1u))))));
    size =
        (((size) >
          (((PageSize)
            ((PageSize)
             ((PageSize) ((sizeof(FreeBlock) + sizeof(PageSize))) +
              (PageSize) (((((sizeof(double)) >
                             (4)) ? (sizeof(double)) : (4))) -
                          1u)) &
             ((PageSize) (~((PageSize) (((((sizeof(double)) > (4)) ? (sizeof(double)) : (4))) - 1u)))))))) ? (size)
         : (((PageSize)
             ((PageSize)
              ((PageSize) ((sizeof(FreeBlock) + sizeof(PageSize))) +
               (PageSize) (((((sizeof(double)) >
                              (4)) ? (sizeof(double)) : (4))) -
                           1u)) &
              ((PageSize) (~((PageSize) (((((sizeof(double)) > (4)) ? (sizeof(double)) : (4))) - 1u))))))));

    if ((rover = chunk->rovers[type]) == 0)
        goto addPage;
    savedRover = rover;

    while (size > rover->largestFree) {
      skipTest:
        if ((rover = rover->next) == savedRover) {
          addPage:
            if (!(flags & 0x0010u)
                && _spaces__newPage(chunk, type, chunk->pageSize, 0, 0));

            else if (!(flags & 0x0020u)
                     && chunk->pageTotal +
                     ((PageSize)
                      ((PageSize) ((PageSize) (size) + (PageSize) ((0x00010000lu) - 1u)) &
                       ((PageSize) (~((PageSize) ((0x00010000lu) - 1u))))))
                     <= chunk->ceiling)
                return _spaces__allocExternal(chunk, flags, size);
            else
                return 0;

            rover = chunk->rovers[type];
            savedRover = rover->next;
        }
    }

    {
        Page *page;
        void *result;

        page = rover->page;
        result = _spaces__allocBlock(page, size, flags);


        if (result) {
            chunk->rovers[type] = rover;
            return result;
        } else
            goto skipTest;
    }
};

void *_spaces__allocBlock(Page * page, register PageSize size, unsigned flags)
{
    register FreeBlock *blockRover = page->hdr.var.rover;
    FreeBlock *savedRover = blockRover;

    register PageSize freeSize;
    register PageSize largestFree = 0;

    while ((freeSize = blockRover->sizeAndTags) < size) {
        if (freeSize > largestFree)
            largestFree = freeSize;
        blockRover = blockRover->next;

        if (blockRover == savedRover) {

            page->pageHeader->largestFree = largestFree & ~(((PageSize) 2u) | ((PageSize) 1u));

            return 0;
        }
    }

    {
        Block *result;

        freeSize &= ~(((PageSize) 2u) | ((PageSize) 1u));

        if ((freeSize -= size) < (page->hdr.var.minBlockSize)) {

            result = (Block *) blockRover;
            blockRover = blockRover->next;
            _spaces__removeFromFreeList((FreeBlock *) result);
            ((result)->sizeAndTags |= ((PageSize) 1u));
            size = ((result)->sizeAndTags & ((PageSize) (~3u)));
            ((((Block *) ((char *) (result) + (size))))->sizeAndTags |= ((PageSize) 2u));
        } else {
            {

                result = ((Block *) ((char *) (blockRover) + (freeSize)));
                ((blockRover)->sizeAndTags =
                 (PageSize) (((*((PageSize *) (result) - 1)) = freeSize) | (0) | (((PageSize) 2u))));
                blockRover = blockRover->next;
                ((((Block *) ((char *) (result) + (size))))->sizeAndTags |= ((PageSize) 2u));
                ((result)->sizeAndTags = (PageSize) ((size) | (((PageSize) 1u)) | (0u)));
            }
        }
        page->hdr.var.rover = blockRover;
        if (flags & 0x0001u)
            memset(result + 1, 0, size - sizeof(Block));
        page->allocCount++;
        return result + 1;
    }
};

Bool spaces_chunk_free(void *mem)
{
    {
    };

    {
        Bool pageDeleted = 0;

        Chunk *p = ((Page *) (((unsigned long) (mem) & ((0x7fffffffffffffffL * 2UL + 1UL)
                                                        - (0x00010000lu - 1))) +
                              ((PageSize)
                               ((PageSize) ((PageSize) (sizeof(Area)) + (PageSize) ((sizeof(double)) - 1u)) &
                                ((PageSize) (~((PageSize) ((sizeof(double)) - 1u))))))))->chunk, *chunk = p;

        {
            if (((chunk)->flags & 0x0002u) && spaces__smpEnqueueFree(p, mem))
                return 1;
        };

        ((*_spaces__freeFns[((PageType) ((((Page *) (((unsigned long) (mem) & ((0x7fffffffffffffffL * 2UL + 1UL)
                                                                               - (0x00010000lu - 1))) +
                                                     ((PageSize)
                                                      ((PageSize)
                                                       ((PageSize) (sizeof(Area)) +
                                                        (PageSize) ((sizeof(double)) -
                                                                    1u)) &
                                                       ((PageSize) (~((PageSize) ((sizeof(double)) - 1u)))))))))->
                                         flagsAndSignature & ((PageType) 0x000F)))]) (mem, &pageDeleted));

        if (!pageDeleted) {
            {
                if (((chunk)->flags & 0x0002u) && !(chunk)->locktid) {
                    if (!spaces__preForkLock) { {
                            if ((chunk)->smpFreeQueue)
                                spaces__smpFlushQueue(chunk);
                    };
                    }
                    ((chunk)->lock = 1);
                }
            };
        };
    }

    return 1;
};

void _spaces__freeVar(void *mem, Bool * pageDeleted)
{
    register Block *block = (Block *) mem - 1;
    register Block *nextBlock;
    Bool bAddToFreeList = 1;
    Page *page = ((Page *) (((unsigned long) (block) & ((0x7fffffffffffffffL * 2UL + 1UL)
                                                        - (0x00010000lu - 1))) +
                            ((PageSize)
                             ((PageSize) ((PageSize) (sizeof(Area)) + (PageSize) ((sizeof(double)) - 1u)) &
                              ((PageSize) (~((PageSize) ((sizeof(double)) - 1u))))))));

    if (!((block)->sizeAndTags & ((PageSize) 2u))) {

        nextBlock = block;
        block = ((Block *) ((char *) (block) - ((*((PageSize *) (block) - 1)))));
        ((block)->sizeAndTags += (((nextBlock)->sizeAndTags & ((PageSize) (~3u)))));
        bAddToFreeList = 0;
    } else
        ((block)->sizeAndTags &= ~((PageSize) 1u));
    nextBlock = ((Block *) ((char *) (block) + (((block)->sizeAndTags & ((PageSize) (~3u))))));
    if (!((nextBlock)->sizeAndTags & ((PageSize) 1u))) {

        ((block)->sizeAndTags += (((nextBlock)->sizeAndTags & ((PageSize) (~3u)))));

        if (nextBlock == (Block *) page->hdr.var.rover)
            page->hdr.var.rover = (FreeBlock *) block;
        _spaces__removeFromFreeList((FreeBlock *) nextBlock);

        if (!bAddToFreeList) {
        }
        nextBlock = ((Block *) ((char *) (block) + (((block)->sizeAndTags & ((PageSize) (~3u))))));
    }

    if (((*((PageSize *) (nextBlock) - 1)) = ((block)->sizeAndTags & ((PageSize) (~3u)))) >
        page->pageHeader->largestFree)
        page->pageHeader->largestFree = ((block)->sizeAndTags & ((PageSize) (~3u)));

    ((nextBlock)->sizeAndTags &= ~((PageSize) 2u));
    if (bAddToFreeList) {

        if (page->hdr.var.freeList->next != page->hdr.var.freeList)
            ((page->pageHeader)->moveableFlags &= ~((0x7fffffffffffffffL * 2UL + 1UL)
                                                    - ((0x7fffffffffffffffL * 2UL + 1UL)
                                                       >> 1)));

        _spaces__insertIntoFreeList((FreeBlock *) block, page->hdr.var.freeList);
    }

    if (--page->allocCount == 0)
        *pageDeleted = spaces__deletePage(page, 0);
};

void *spaces_chunk_realloc(void *mem, size_t size, unsigned flags)
{
    Page *page;
    Chunk *chunk;
    PageSize bytesToCopy;
    PageType type;

    {
    };

    page = ((Page *) (((unsigned long) (mem) & ((0x7fffffffffffffffL * 2UL + 1UL)
                                                - (0x00010000lu - 1))) +
                      ((PageSize)
                       ((PageSize) ((PageSize) (sizeof(Area)) + (PageSize) ((sizeof(double)) - 1u)) &
                        ((PageSize) (~((PageSize) ((sizeof(double)) - 1u))))))));
    type = ((PageType) ((page)->flagsAndSignature & ((PageType) 0x000F)));
    chunk = page->chunk;

    if (type == ((PageType) 3) && page->hdr.ext.alignment != 0) {
        _spaces__invokeErrorHandler1(chunk, SPACES_ERR_BAD_POINTER);
        return 0;
    }

    if (type != ((PageType) 3)
        && size && (chunk->flags & 0x0002u)
        && !((((chunk)->lock) && spaces__test_and_clear(&(chunk)->lock)))
        ) {
        size_t oldSize = spaces__memSizePtr(mem);

        bytesToCopy = (PageSize) (((size) < (oldSize)) ? (size) : (oldSize));
    } else {

        bytesToCopy = _spaces__resizeAny((flags & 0x0008u) ? 0 : &mem, mem, size, flags);

        if (bytesToCopy == 0) {
        }

        if (type != ((PageType) 3) && size) {
            {
                if (((chunk)->flags & 0x0002u) && !(chunk)->locktid) {
                    if (!spaces__preForkLock) { {
                            if ((chunk)->smpFreeQueue)
                                spaces__smpFlushQueue(chunk);
                    };
                    }
                    ((chunk)->lock = 1);
                }
            };
        }
    }

    if (bytesToCopy == 0) {
        return mem;
    } else if (!(flags & 0x0008u)) {

        void *result;

        result = spaces_chunk_alloc(chunk, size, flags);

        if (result) {
            mem = mem;

            memcpy(result, mem, bytesToCopy);
            spaces_chunk_free(mem);

            result = result;

        }

        return result;
    } else if ((size - 0) != 0)
        _spaces__invokeErrorHandler1(chunk, SPACES_ERR_RESIZE_FAILED);

    return 0;
};

PageSize _spaces__resizeAny(void * *dst, void *mem, size_t size, unsigned flags)
{
    Page *page = ((Page *) (((unsigned long) (mem) & ((0x7fffffffffffffffL * 2UL + 1UL)
                                                      - (0x00010000lu - 1))) +
                            ((PageSize)
                             ((PageSize) ((PageSize) (sizeof(Area)) + (PageSize) ((sizeof(double)) - 1u)) &
                              ((PageSize) (~((PageSize) ((sizeof(double)) - 1u))))))));

    if ((size - 0) == 0) {
        _spaces__invokeErrorHandler1(page->chunk, SPACES_ERR_ALLOC_ZERO);
        if (dst) {
            *dst = 0;
            return 0;
        } else
            return 1;
    }

    switch (((PageType) ((page)->flagsAndSignature & ((PageType) 0x000F)))) {
    case ((PageType) 4):
    case ((PageType) 5):
        {
            unsigned oldIndex, newIndex;
            PageSize oldSize;

            if (((PageType) ((page)->flagsAndSignature & ((PageType) 0x000F))) == ((PageType) 4)) {
                oldIndex = (*((unsigned char *) (mem) - 0 - 1));
                oldSize =
                    ((((oldIndex) << 3) +
                      ((PageSize)
                       ((PageSize) ((PageSize) (0 + 1) + (PageSize) ((sizeof(double)) - 1u)) &
                        ((PageSize) (~((PageSize) ((sizeof(double)) - 1u))))))) - 0 - 1);
                newIndex =
                    (unsigned) ((((((size) >
                                    (sizeof(FreeSmallBlock *))) ? (size) : (sizeof(FreeSmallBlock *)))) +
                                 ((PageSize)
                                  ((PageSize) ((PageSize) (0) + (PageSize) ((sizeof(double)) - 1u)) &
                                   ((PageSize) (~((PageSize) ((sizeof(double)) - 1u)))))) - 0) >> 3);
            } else {
                oldIndex = page->hdr.fs.index;
                oldSize =
                    ((((oldIndex) << 3) +
                      ((PageSize)
                       ((PageSize) ((PageSize) (0) + (PageSize) ((sizeof(double)) - 1u)) &
                        ((PageSize) (~((PageSize) ((sizeof(double)) - 1u))))))) - 0);
                newIndex =
                    (((((PageSize)
                        ((PageSize) ((PageSize) (size) + (PageSize) ((sizeof(double)) - 1u)) &
                         ((PageSize) (~((PageSize) ((sizeof(double)) - 1u))))))) +
                      ((PageSize)
                       ((PageSize) ((PageSize) (0) + (PageSize) ((sizeof(double)) - 1u)) &
                        ((PageSize) (~((PageSize) ((sizeof(double)) - 1u)))))) - 0) >> 3);
            }

            if ((flags & 0x0008u) ? (size <= oldSize)
                : (size <= page->chunk->smallSize && oldIndex == newIndex)) {
                if ((flags & 0x0001u) && (PageSize) size < oldSize)
                    memset((char *) mem + (PageSize) size, 0, oldSize - (PageSize) size);
            } else
                return (PageSize) (((size) < (oldSize)) ? (size) : (oldSize));
            break;
        }

    case ((PageType) 0):

    case ((PageType) 1):
        if (size > page->chunk->blockSizeFS)
            return page->chunk->blockSizeFS;
        else if ((flags & 0x0001u)
                 && (PageSize) size < page->chunk->blockSizeFS) {

            memset((char *) mem + (PageSize) size, 0, page->chunk->blockSizeFS - (PageSize) size);
        }
        break;

    case ((PageType) 3):
        if ((!dst || size > page->chunk->maxSubAlloc)
            && page->hdr.ext.alignment == 0) {

            if (!_spaces__resizeExternal(page, dst, size, flags)
                && !dst)
                return 1;
        } else {
            size_t oldSize = spaces__memSizePtr(mem);

            return (PageSize) (((size) < (oldSize)) ? (size) : (oldSize));
        }
        break;

    default:
        break;
    }

    return 0;
};

Bool _spaces__resizeVar(register Block * block, PageSize size)
{
    register PageSize curSize = ((block)->sizeAndTags & ((PageSize) (~((PageSize) ((0x7fffffffffffffffL * 2UL + 1UL)
                                                                                   - ((0x7fffffffffffffffL * 2UL + 1UL)
                                                                                      >> 1)) | 3u))));
    PageSize newNextBlockSize;
    Block *nextBlock;

    size =
        ((PageSize)
         ((PageSize)
          ((PageSize) ((size + sizeof(Block))) +
           (PageSize) (((((sizeof(double)) >
                          (4)) ? (sizeof(double)) : (4))) -
                       1u)) &
          ((PageSize) (~((PageSize) (((((sizeof(double)) > (4)) ? (sizeof(double)) : (4))) - 1u))))));
    size =
        (((size) >
          (((PageSize)
            ((PageSize)
             ((PageSize) ((sizeof(FreeBlock) + sizeof(PageSize))) +
              (PageSize) (((((sizeof(double)) >
                             (4)) ? (sizeof(double)) : (4))) -
                          1u)) &
             ((PageSize) (~((PageSize) (((((sizeof(double)) > (4)) ? (sizeof(double)) : (4))) - 1u)))))))) ? (size)
         : (((PageSize)
             ((PageSize)
              ((PageSize) ((sizeof(FreeBlock) + sizeof(PageSize))) +
               (PageSize) (((((sizeof(double)) >
                              (4)) ? (sizeof(double)) : (4))) -
                           1u)) &
              ((PageSize) (~((PageSize) (((((sizeof(double)) > (4)) ? (sizeof(double)) : (4))) - 1u))))))));

    if (size <= curSize) {

        if ((newNextBlockSize = curSize - size) >=
            (((block)->sizeAndTags & (PageSize) ((0x7fffffffffffffffL * 2UL + 1UL)
                                                 - ((0x7fffffffffffffffL * 2UL + 1UL)
                                                    >> 1)))
             ? ((PageSize)
                ((PageSize)
                 ((PageSize) ((sizeof(FreeBlock) + sizeof(PageSize))) +
                  (PageSize) (((((sizeof(double)) >
                                 (4)) ? (sizeof(double)) : (4))) -
                              1u)) &
                 ((PageSize) (~((PageSize) (((((sizeof(double)) > (4)) ? (sizeof(double)) : (4))) - 1u)))))) : ((Page
                                                                                                                 *) (((unsigned long) (block) & ((0x7fffffffffffffffL * 2UL + 1UL)
                                                                                                                                                 -
                                                                                                                                                 (0x00010000lu
                                                                                                                                                  -
                                                                                                                                                  1)))
                                                                                                                     +
                                                                                                                     ((PageSize) ((PageSize) ((PageSize) (sizeof(Area)) + (PageSize) ((sizeof(double)) - 1u)) & ((PageSize) (~((PageSize) ((sizeof(double)) - 1u))))))))->hdr.var.minBlockSize)) {

            nextBlock = ((Block *) ((char *) (block) + (curSize)));
            if (!((nextBlock)->sizeAndTags & ((PageSize) 1u))) {
                newNextBlockSize += ((nextBlock)->sizeAndTags & ((PageSize) (~3u)));
                if (nextBlock == (Block *) ((Page *) (((unsigned long) (block) & ((0x7fffffffffffffffL * 2UL + 1UL)
                                                                                  - (0x00010000lu - 1))) +
                                                      ((PageSize)
                                                       ((PageSize)
                                                        ((PageSize) (sizeof(Area)) +
                                                         (PageSize) ((sizeof(double)) -
                                                                     1u)) &
                                                        ((PageSize) (~((PageSize) ((sizeof(double)) - 1u))))))))->hdr.
                    var.rover)
                    ((Page *) (((unsigned long) (block) & ((0x7fffffffffffffffL * 2UL + 1UL)
                                                           - (0x00010000lu - 1))) +
                               ((PageSize)
                                ((PageSize) ((PageSize) (sizeof(Area)) + (PageSize) ((sizeof(double)) - 1u)) &
                                 ((PageSize) (~((PageSize) ((sizeof(double)) - 1u))))))))->hdr.var.rover =
                        ((FreeBlock *) nextBlock)->next;
                _spaces__removeFromFreeList((FreeBlock *) nextBlock);
            }

            if (newNextBlockSize > ((Page *) (((unsigned long) (block) & ((0x7fffffffffffffffL * 2UL + 1UL)
                                                                          - (0x00010000lu - 1))) +
                                              ((PageSize)
                                               ((PageSize)
                                                ((PageSize) (sizeof(Area)) +
                                                 (PageSize) ((sizeof(double)) -
                                                             1u)) &
                                                ((PageSize) (~((PageSize) ((sizeof(double)) - 1u))))))))->pageHeader->
                largestFree)
                ((Page *) (((unsigned long) (block) & ((0x7fffffffffffffffL * 2UL + 1UL)
                                                       - (0x00010000lu - 1))) +
                           ((PageSize)
                            ((PageSize) ((PageSize) (sizeof(Area)) + (PageSize) ((sizeof(double)) - 1u)) &
                             ((PageSize) (~((PageSize) ((sizeof(double)) - 1u))))))))->pageHeader->largestFree =
                    newNextBlockSize;

          splitRemainderFreeBlock:

            ((block)->sizeAndTags = (PageSize) (((block)->sizeAndTags & ~((PageSize) (~((PageSize) ((0x7fffffffffffffffL
                                                                                                     * 2UL + 1UL)
                                                                                                    -
                                                                                                    ((0x7fffffffffffffffL * 2UL + 1UL)
                                                                                                     >> 1)) | 3u)))) |
                                                (size)));
            nextBlock = ((Block *) ((char *) (block) + (size)));
            ((nextBlock)->sizeAndTags = (PageSize) ((newNextBlockSize) | (0) | (((PageSize) 2u))));
            _spaces__insertIntoFreeList((FreeBlock *) nextBlock,
                                        ((Page *) (((unsigned long) (block) & ((0x7fffffffffffffffL * 2UL + 1UL)
                                                                               - (0x00010000lu - 1))) +
                                                   ((PageSize)
                                                    ((PageSize)
                                                     ((PageSize) (sizeof(Area)) +
                                                      (PageSize) ((sizeof(double)) -
                                                                  1u)) &
                                                     ((PageSize) (~((PageSize) ((sizeof(double)) - 1u))))))))->hdr.var.
                                        freeList);
            nextBlock = ((Block *) ((char *) (nextBlock) + (newNextBlockSize)));
            (*((PageSize *) (nextBlock) - 1)) = newNextBlockSize;
            ((nextBlock)->sizeAndTags &= ~((PageSize) 2u));
        }
        return 1;
    } else if (!((nextBlock = ((Block *) ((char *) (block) + (curSize))))->sizeAndTags & ((PageSize) 1u))
               && size <= curSize + ((nextBlock)->sizeAndTags & ((PageSize) (~3u)))) {

        if ((FreeBlock *) nextBlock == ((Page *) (((unsigned long) (block) & ((0x7fffffffffffffffL * 2UL + 1UL)
                                                                              - (0x00010000lu - 1))) +
                                                  ((PageSize)
                                                   ((PageSize)
                                                    ((PageSize) (sizeof(Area)) +
                                                     (PageSize) ((sizeof(double)) -
                                                                 1u)) &
                                                    ((PageSize) (~((PageSize) ((sizeof(double)) - 1u))))))))->hdr.var.
            rover)
            ((Page *) (((unsigned long) (block) & ((0x7fffffffffffffffL * 2UL + 1UL)
                                                   - (0x00010000lu - 1))) +
                       ((PageSize)
                        ((PageSize) ((PageSize) (sizeof(Area)) + (PageSize) ((sizeof(double)) - 1u)) &
                         ((PageSize) (~((PageSize) ((sizeof(double)) - 1u))))))))->hdr.var.rover =
                ((FreeBlock *) nextBlock)->next;
        _spaces__removeFromFreeList((FreeBlock *) nextBlock);
        if ((newNextBlockSize = curSize + ((nextBlock)->sizeAndTags & ((PageSize) (~3u))) - size)
            >= (((block)->sizeAndTags & (PageSize) ((0x7fffffffffffffffL * 2UL + 1UL)
                                                    - ((0x7fffffffffffffffL * 2UL + 1UL)
                                                       >> 1)))
                ? ((PageSize)
                   ((PageSize)
                    ((PageSize) ((sizeof(FreeBlock) + sizeof(PageSize))) +
                     (PageSize) (((((sizeof(double)) >
                                    (4)) ? (sizeof(double)) : (4))) -
                                 1u)) &
                    ((PageSize) (~((PageSize) (((((sizeof(double)) > (4)) ? (sizeof(double)) : (4))) - 1u)))))) : ((Page
                                                                                                                    *) (((unsigned long) (block) & ((0x7fffffffffffffffL * 2UL + 1UL)
                                                                                                                                                    -
                                                                                                                                                    (0x00010000lu
                                                                                                                                                     -
                                                                                                                                                     1)))
                                                                                                                        +
                                                                                                                        ((PageSize) ((PageSize) ((PageSize) (sizeof(Area)) + (PageSize) ((sizeof(double)) - 1u)) & ((PageSize) (~((PageSize) ((sizeof(double)) - 1u))))))))->hdr.var.minBlockSize)) {

            goto splitRemainderFreeBlock;
        } else {

            ((block)->sizeAndTags += (((nextBlock)->sizeAndTags & ((PageSize) (~3u)))));
            ((((Block *) ((char *) (nextBlock) + (((nextBlock)->sizeAndTags & ((PageSize) (~3u)))))))->sizeAndTags |=
             ((PageSize) 2u));
        }
        return 1;
    }

    return 0;
};

size_t spaces__memSizePtr(void *mem)
{
    return spaces__memSizePtrRaw(mem, 0);
};

size_t spaces__memSizePtrRaw(void *mem, Bool bRaw)
{
    size_t size = 0;

    switch (((PageType) ((((Page *) (((unsigned long) (mem) & ((0x7fffffffffffffffL * 2UL + 1UL)
                                                               - (0x00010000lu - 1))) +
                                     ((PageSize)
                                      ((PageSize) ((PageSize) (sizeof(Area)) + (PageSize) ((sizeof(double)) - 1u)) &
                                       ((PageSize) (~((PageSize) ((sizeof(double)) - 1u)))))))))->
                         flagsAndSignature & ((PageType) 0x000F)))) {
    case ((PageType) 4):
        {
            unsigned index = (*((unsigned char *) (mem) - 0 - 1));

            size =
                ((((index) << 3) +
                  ((PageSize)
                   ((PageSize) ((PageSize) (0 + 1) + (PageSize) ((sizeof(double)) - 1u)) &
                    ((PageSize) (~((PageSize) ((sizeof(double)) - 1u))))))) - 0 - 1);
            break;
        }

    case ((PageType) 5):
        size = ((((((Page *) (((unsigned long) (mem) & ((0x7fffffffffffffffL * 2UL + 1UL)
                                                        - (0x00010000lu - 1))) +
                              ((PageSize)
                               ((PageSize) ((PageSize) (sizeof(Area)) + (PageSize) ((sizeof(double)) - 1u)) &
                                ((PageSize) (~((PageSize) ((sizeof(double)) - 1u))))))))->hdr.fs.index) << 3) +
                 ((PageSize)
                  ((PageSize) ((PageSize) (0) + (PageSize) ((sizeof(double)) - 1u)) &
                   ((PageSize) (~((PageSize) ((sizeof(double)) - 1u))))))) - 0);
        break;

    case ((PageType) 0):

    case ((PageType) 1):
        size = ((Page *) (((unsigned long) (mem) & ((0x7fffffffffffffffL * 2UL + 1UL)
                                                    - (0x00010000lu - 1))) +
                          ((PageSize)
                           ((PageSize) ((PageSize) (sizeof(Area)) + (PageSize) ((sizeof(double)) - 1u)) &
                            ((PageSize) (~((PageSize) ((sizeof(double)) - 1u))))))))->chunk->blockSizeFS;
        break;

    case ((PageType) 3):
        {
            Page *page = ((Page *) (((unsigned long) (mem) & ((0x7fffffffffffffffL * 2UL + 1UL)
                                                              - (0x00010000lu - 1))) +
                                    ((PageSize)
                                     ((PageSize) ((PageSize) (sizeof(Area)) + (PageSize) ((sizeof(double)) - 1u)) &
                                      ((PageSize) (~((PageSize) ((sizeof(double)) - 1u))))))));

            size =
                _spaces__sysSize(page) -
                ((PageSize)
                 ((PageSize) ((PageSize) (sizeof(Page) + (0)) + (PageSize) ((sizeof(double)) - 1u)) &
                  ((PageSize) (~((PageSize) ((sizeof(double)) - 1u))))));

            if (page->hdr.ext.alignment && !bRaw)
                size -= page->hdr.ext.alignment;

            break;
        }

    default:
        break;
    }

    return size;
};

size_t spaces_chunk_ptr_size(void *mem)
{
    size_t size;

    {
    };

    size = spaces__memSizePtr(mem);

    return size;
};

static unsigned _spaces__normalizePageSize(unsigned);
static SpacesChunk _spaces__initChunk(unsigned short blockSize,
                                      size_t blockCount, size_t totalSize, unsigned flags,
                                      void *addr, unsigned pidCount, unsigned long *pids,
                                      void *security, const char *name);
static SpacesChunk spaces__chunkAttachShared(SpacesChunk chunk, const char *name);

Chunk *spaces_chunk_create(unsigned flags)
{
    return _spaces__initChunk(0, 0, 0, flags, 0, 0, 0, 0, 0);
};

Chunk *spaces__initSubChunk(SpacesChunk parent, unsigned flags)
{
    Chunk *chunk, *addr;


    flags |= parent->flags | 0x4000u;

    if (flags & (0x0010u | 0x0001u))
        addr = parent;
    else
        addr = 0;

    chunk = _spaces__initChunk(0, 0, 0, flags, addr, 0, 0, 0, 0);

    if (chunk) {
        chunk->subChunkSharing = 0;

        chunk->blockSizeFS = parent->blockSizeFS;
        chunk->smallSize = parent->smallSize;
        chunk->pageSize = parent->pageSize;
        chunk->minPageSize = parent->minPageSize;
        chunk->pageResizing = parent->pageResizing;
        chunk->maxSubAlloc = parent->maxSubAlloc;
        chunk->floor = parent->floor;
        chunk->ceiling = parent->ceiling;
        chunk->floor = parent->floor;

        if (chunk->flags & 0x00040000u)
            chunk->growIncrement = parent->growIncrement;
        else
            chunk->growIncrement = (64 * 1024L);
        if (chunk->flags & 0x00080000u)
            chunk->freeBytes = parent->freeBytes;
        else
            chunk->freeBytes = (256 * 1024L);
    }

    return chunk;
};

Chunk *spaces_chunk_create_fixed(unsigned short blockSize, size_t blockCount, unsigned flags)
{
    return _spaces__initChunk(blockSize, blockCount, 0, flags, 0, 0, 0, 0, 0);
};

Chunk *spaces_chunk_create_area(void *addr, size_t size, unsigned flags)
{

    return spaces_chunk_create_area_ex(addr, size, flags, 0);
};

Chunk *spaces_chunk_create_area_ex(void *addr, size_t size, unsigned flags, void *security)
{
    if (flags & 0x4000u) {
        _spaces__invokeErrorHandler1(0, SPACES_ERR_BAD_FLAGS);
        flags &= ~0x4000u;
    }

    return _spaces__initChunk(0, 0, size, flags | 0x0010u, addr, 0, 0, security, 0);
};

Chunk *spaces_chunk_create_shared(const char *name, size_t size, unsigned flags)
{
    return _spaces__initChunk(0, 0, size, flags | 0x0001u, 0, 0, 0, 0, name);
};

Chunk *spaces_chunk_attach_shared(SpacesChunk chunk, const char *name)
{


    chunk = spaces__chunkAttachShared(chunk, name);


    return chunk;
};

static Chunk *spaces__chunkAttachShared(SpacesChunk chunk, const char *name)
{
    Bool bWasAttached = 0;

    if ((chunk = _spaces__registerShared(chunk, name, 0, &bWasAttached)) != 0 && !bWasAttached) {
        TaskRecord *taskRec = (&_spaces__TaskRecord);

        if (!taskRec) {
            _spaces__chunkFree(chunk, 0);
            chunk = 0;
        } else {
            {
                if (!spaces__createAndEnterMutex(&spaces__mutexGlobal))
                    return 0;
            };
            (*(((chunk)->flags & 0x0001u) ? _spaces__getNextChunk(chunk) : &((chunk)->task.private_.next))) =
                taskRec->chunks;
            taskRec->chunks = chunk;
            {
                if (!spaces__preInitThreads)
                    (--(&spaces__mutexGlobal)->count, pthread_mutex_unlock(&(&spaces__mutexGlobal)->m));
            };
        }
    }

    return chunk;
};

static SpacesChunk _spaces__initChunk(unsigned short blockSize,
                                      size_t blockCount, size_t totalSize, unsigned flags,
                                      void *addr, unsigned pidCount, unsigned long *pids,
                                      void *security, const char *name)
{
    Chunk *chunk;
    PageType i;
    TaskRecord *taskRec = (&_spaces__TaskRecord);

    if (!taskRec)
        return 0;

    if (spaces__preInitThreads)
        flags &= ~(0x0002u | 0x8000u);


    do {

        if (name) {
            if ((chunk = spaces__chunkAttachShared(0, name)) != 0) {
                return chunk;
            } else
                chunk = (Chunk *)
                    _spaces__sysAllocNamedShared((((sizeof(Chunk)) >
                                                   ((0x00010000lu -
                                                     ((PageSize)
                                                      ((PageSize)
                                                       ((PageSize) (sizeof(Area)) +
                                                        (PageSize) ((sizeof(double)) -
                                                                    1u)) &
                                                       ((PageSize) (~((PageSize) ((sizeof(double)) - 1u)))))))))
                                                  ? (sizeof(Chunk))
                                                  : ((0x00010000lu -
                                                      ((PageSize)
                                                       ((PageSize)
                                                        ((PageSize) (sizeof(Area)) +
                                                         (PageSize) ((sizeof(double)) -
                                                                     1u)) &
                                                        ((PageSize) (~((PageSize) ((sizeof(double)) - 1u))))))))),
                                                 totalSize, flags | 0x1000u | 0x0100u, addr, pidCount, pids, security,
                                                 name);
        } else if (addr) {

            chunk =
                spaces__sysAllocArea((((sizeof(Chunk)) >
                                       ((0x00010000lu -
                                         ((PageSize)
                                          ((PageSize) ((PageSize) (sizeof(Area)) + (PageSize) ((sizeof(double)) - 1u)) &
                                           ((PageSize) (~((PageSize) ((sizeof(double)) - 1u))))))))) ? (sizeof(Chunk))
                                      : ((0x00010000lu -
                                          ((PageSize)
                                           ((PageSize) ((PageSize) (sizeof(Area)) + (PageSize) ((sizeof(double)) - 1u))
                                            & ((PageSize) (~((PageSize) ((sizeof(double)) - 1u))))))))), totalSize,
                                     flags | 0x1000u | 0x0100u, addr, security);
        } else {

            chunk =
                (Chunk *) _spaces__sysAllocChunk(0,
                                                 (((sizeof(Chunk)) >
                                                   ((0x00010000lu -
                                                     ((PageSize)
                                                      ((PageSize)
                                                       ((PageSize) (sizeof(Area)) +
                                                        (PageSize) ((sizeof(double)) -
                                                                    1u)) &
                                                       ((PageSize) (~((PageSize) ((sizeof(double)) - 1u)))))))))
                                                  ? (sizeof(Chunk))
                                                  : ((0x00010000lu -
                                                      ((PageSize)
                                                       ((PageSize)
                                                        ((PageSize) (sizeof(Area)) +
                                                         (PageSize) ((sizeof(double)) -
                                                                     1u)) &
                                                        ((PageSize) (~((PageSize) ((sizeof(double)) - 1u))))))))),
                                                 (flags | 0x1000u | 0x0100u) & ~0x0004u);
        }
    }
    while (!chunk && _spaces__invokeErrorHandler1(chunk, SPACES_ERR_OUT_OF_MEMORY));

    if (!chunk)
        goto fail;

    for (i = 0; i < ((PageType) 7); i++)
        chunk->rovers[i] = 0;
    chunk->freePages = 0;
    chunk->signature = 0xBEADu;

    chunk->flags = (flags & ~0x0002u);
    chunk->blockSizeFS = 0;
    chunk->smallSize = 512;
    chunk->allocSmallFn = SPACES_SMALL_V5;
    if (!chunk->pageSize) {
        chunk->pageSize =
            (PageSize) (0x00010000lu -
                        ((PageSize)
                         ((PageSize) ((PageSize) (sizeof(Area)) + (PageSize) ((sizeof(double)) - 1u)) &
                          ((PageSize) (~((PageSize) ((sizeof(double)) - 1u)))))));

        chunk->maxSubAlloc =
            ((PageSize)
             (chunk->pageSize -
              ((PageSize)
               ((PageSize) ((PageSize) (sizeof(Page) + (sizeof(struct _Block))) + (PageSize) ((sizeof(double)) - 1u)) &
                ((PageSize) (~((PageSize) ((sizeof(double)) - 1u)))))) -
              ((PageSize)
               ((PageSize)
                ((PageSize) ((sizeof(FreeBlock) + sizeof(PageSize))) +
                 (PageSize) (((((sizeof(double)) >
                                (4)) ? (sizeof(double)) : (4))) -
                             1u)) &
                ((PageSize) (~((PageSize) (((((sizeof(double)) > (4)) ? (sizeof(double)) : (4))) - 1u))))))));
    }

    chunk->minPageSize = chunk->pageSize;
    chunk->pageResizing = 0;

    chunk->floor = 0;

    chunk->ceiling = ((size_t) (MSIGNEDSIZET) - 2);

    chunk->growIncrement = (64 * 1024L);
    chunk->freeBytes = (256 * 1024L);
    chunk->totalFree = 0;
    chunk->compactChunkFn = 0;
    chunk->compactPageFn = 0;
    chunk->pages[0].page = 0;

    chunk->extraPages = 0;
    if ((flags & 0x0001u) && !(flags & 0x0010u))
        flags |= 0x0002u;

    if (flags & 0x8000u)
        flags |= 0x0002u;

    if (flags & 0x0002u) {
        if (((((chunk)->mutex.count) =
              0), ((chunk)->flags & 0x0001u) ? _spaces__initSharedSem(chunk) : spaces__initMutex(&((chunk)->mutex))))
            chunk->flags = flags;
        else {
            _spaces__sysFreeChunk(chunk, chunk);
            chunk = 0;
            goto fail;
        }
    }

    if (flags & (0x0001u | 0x0010u)) {
        if (!_spaces__registerShared(chunk, name, 1, 0)) {

            chunk = 0;
            goto fail;
        }
    }

    spaces__smpInitChunk(chunk);

    {
        if (!spaces__createAndEnterMutex(&spaces__mutexGlobal))
            return 0;
    };

    if (!(flags & 0x0001u))
        chunk->task.private_.taskRec = taskRec;
    (*(((chunk)->flags & 0x0001u) ? _spaces__getNextChunk(chunk) : &((chunk)->task.private_.next))) = taskRec->chunks;
    taskRec->chunks = chunk;
    {
        if (!spaces__preInitThreads)
            (--(&spaces__mutexGlobal)->count, pthread_mutex_unlock(&(&spaces__mutexGlobal)->m));
    };

    chunk->pageTotal =
        ((unsigned
          long) ((unsigned long) ((unsigned long) ((_spaces__sysSize(chunk))) +
                                  (unsigned long) ((0x00010000lu) -
                                                   1u)) & ((unsigned
                                                            long) (~((unsigned long) ((0x00010000lu) - 1u))))));

    if (blockSize && !spaces_chunk_set_block_size(chunk, blockSize)) {
        _spaces__chunkFree(chunk, 0);
        chunk = 0;
        goto fail;
    }

    if (blockCount) {
        {
            if ((chunk)->flags & 0x0002u) {
                if ((chunk)->flags & 0x0001u) {
                    if (!_spaces__lockSharedSem(chunk))
                        return 0;
                } else { {
                        if (!(pthread_mutex_lock(&(&((chunk)->mutex))->m) == 0 && ++(&((chunk)->mutex))->count))
                            return 0;
                        if ((chunk)->mutex.count == 1) {
                            if (((chunk)->flags & 0x0002u)) { {
                                    int i___ = 2;
                                    int k___ = 0;
                                    while (!((((chunk)->lock) && spaces__test_and_clear(&(chunk)->lock)))) {;
                                        if (i___-- == 0) {
                                            spaces__smpYield(k___++);
                                            i___ = 2;
                                        }
                                    }
                            }
                            };
                        }
                };
                }
            }
        };

        spaces__preallocBytes(chunk, ((PageType) 1), blockCount * (size_t) (chunk->blockSizeFS + 0));

        {
            if ((chunk)->flags & 0x0002u) {
                if ((chunk)->flags & 0x0001u)
                    _spaces__unlockSharedSem(chunk);
                else { {
                        if ((chunk)->mutex.count == 1) { {
                                if (((chunk)->flags & 0x0002u) && !(chunk)->locktid) {
                                    if (!spaces__preForkLock) { {
                                            if ((chunk)->smpFreeQueue)
                                                spaces__smpFlushQueue(chunk);
                                    };
                                    }
                                    ((chunk)->lock = 1);
                                }
                        };
                        }
                        (--(&((chunk)->mutex))->count, pthread_mutex_unlock(&(&((chunk)->mutex))->m));
                };
                }
            }
        };
    }
  fail:

    return chunk;
};

unsigned spaces_chunk_set_page_size(SpacesChunk chunk, unsigned pageSize)
{
    PageSize oldSize;

    {
        if (!(chunk)) {
            (chunk) = (spaces_default_chunk = spaces_init_default_chunk());
        }
    };
    {
        if ((chunk)->flags & 0x8000u) {
            ThreadID tid_ = pthread_self();
            ThreadLocalChunk *tlp_ = &spaces__threadLocalChunks[tid_ % 997];
            if (tlp_->tid == tid_)
                (chunk) = tlp_->chunk;
        };
    };

    pageSize = _spaces__normalizePageSize(pageSize);

    {
        if ((chunk)->smpParent)
            (chunk) = (chunk)->smpParent;
        do { {
                if ((chunk)->flags & 0x0002u) {
                    if ((chunk)->flags & 0x0001u) {
                        if (!_spaces__lockSharedSem(chunk))
                            return 0;
                    } else { {
                            if (!(pthread_mutex_lock(&(&((chunk)->mutex))->m) == 0 && ++(&((chunk)->mutex))->count))
                                return 0;
                            if ((chunk)->mutex.count == 1) {
                                if (((chunk)->flags & 0x0002u)) { {
                                        int i___ = 2;
                                        int k___ = 0;
                                        while (!((((chunk)->lock) && spaces__test_and_clear(&(chunk)->lock)))) {;
                                            if (i___-- == 0) {
                                                spaces__smpYield(k___++);
                                                i___ = 2;
                                            }
                                        }
                                }
                                };
                            }
                    };
                    }
                }
        };
        if (pageSize <
            (unsigned) (chunk->blockSizeFS +
                        ((PageSize)
                         ((PageSize) ((PageSize) (sizeof(Page) + (0)) + (PageSize) ((sizeof(double)) - 1u)) &
                          ((PageSize) (~((PageSize) ((sizeof(double)) - 1u))))))))
            oldSize = 0;
        else {
            oldSize = chunk->pageSize;
            chunk->pageSize = (PageSize) pageSize;
            if (chunk->maxSubAlloc >
                ((PageSize)
                 (chunk->pageSize -
                  ((PageSize)
                   ((PageSize)
                    ((PageSize) (sizeof(Page) + (sizeof(struct _Block))) +
                     (PageSize) ((sizeof(double)) - 1u)) & ((PageSize) (~((PageSize) ((sizeof(double)) - 1u)))))) -
                  ((PageSize)
                   ((PageSize)
                    ((PageSize) ((sizeof(FreeBlock) + sizeof(PageSize))) +
                     (PageSize) (((((sizeof(double)) >
                                    (4)) ? (sizeof(double)) : (4))) -
                                 1u)) &
                    ((PageSize) (~((PageSize) (((((sizeof(double)) > (4)) ? (sizeof(double)) : (4))) - 1u)))))))))
                chunk->maxSubAlloc =
                    ((PageSize)
                     (chunk->pageSize -
                      ((PageSize)
                       ((PageSize)
                        ((PageSize) (sizeof(Page) + (sizeof(struct _Block))) +
                         (PageSize) ((sizeof(double)) - 1u)) & ((PageSize) (~((PageSize) ((sizeof(double)) - 1u)))))) -
                      ((PageSize)
                       ((PageSize)
                        ((PageSize) ((sizeof(FreeBlock) + sizeof(PageSize))) +
                         (PageSize) (((((sizeof(double)) >
                                        (4)) ? (sizeof(double)) : (4))) -
                                     1u)) &
                        ((PageSize) (~((PageSize) (((((sizeof(double)) > (4)) ? (sizeof(double)) : (4))) - 1u))))))));
        } {
            if ((chunk)->flags & 0x0002u) {
                if ((chunk)->flags & 0x0001u)
                    _spaces__unlockSharedSem(chunk);
                else { {
                        if ((chunk)->mutex.count == 1) { {
                                if (((chunk)->flags & 0x0002u) && !(chunk)->locktid) {
                                    if (!spaces__preForkLock) { {
                                            if ((chunk)->smpFreeQueue)
                                                spaces__smpFlushQueue(chunk);
                                    };
                                    }
                                    ((chunk)->lock = 1);
                                }
                        };
                        }
                        (--(&((chunk)->mutex))->count, pthread_mutex_unlock(&(&((chunk)->mutex))->m));
                };
                }
            }
        };
        } while (((chunk) = (chunk)->smpNextChunk) != 0 && (chunk) != (chunk)->smpParent);
    }
    return (unsigned) oldSize;
};

unsigned spaces_chunk_set_max_suballoc(SpacesChunk chunk, unsigned val)
{
    PageSize oldVal;

    {
        if (!(chunk)) {
            (chunk) = (spaces_default_chunk = spaces_init_default_chunk());
        }
    };

    {
        if ((chunk)->smpParent)
            (chunk) = (chunk)->smpParent;
        do {
            oldVal = chunk->maxSubAlloc;
            chunk->maxSubAlloc =
                (((val) <
                  (((PageSize)
                    (chunk->pageSize -
                     ((PageSize)
                      ((PageSize)
                       ((PageSize) (sizeof(Page) + (sizeof(struct _Block))) +
                        (PageSize) ((sizeof(double)) - 1u)) & ((PageSize) (~((PageSize) ((sizeof(double)) - 1u)))))) -
                     ((PageSize)
                      ((PageSize)
                       ((PageSize) ((sizeof(FreeBlock) + sizeof(PageSize))) +
                        (PageSize) (((((sizeof(double)) >
                                       (4)) ? (sizeof(double)) : (4))) -
                                    1u)) &
                       ((PageSize) (~((PageSize) (((((sizeof(double)) > (4)) ? (sizeof(double)) : (4))) - 1u))))))))))
                 ? (val)
                 : (((PageSize)
                     (chunk->pageSize -
                      ((PageSize)
                       ((PageSize)
                        ((PageSize) (sizeof(Page) + (sizeof(struct _Block))) +
                         (PageSize) ((sizeof(double)) - 1u)) & ((PageSize) (~((PageSize) ((sizeof(double)) - 1u)))))) -
                      ((PageSize)
                       ((PageSize)
                        ((PageSize) ((sizeof(FreeBlock) + sizeof(PageSize))) +
                         (PageSize) (((((sizeof(double)) >
                                        (4)) ? (sizeof(double)) : (4))) -
                                     1u)) &
                        ((PageSize)
                         (~((PageSize) (((((sizeof(double)) > (4)) ? (sizeof(double)) : (4))) - 1u))))))))));
        } while (((chunk) = (chunk)->smpNextChunk) != 0 && (chunk) != (chunk)->smpParent);
    }

    return (unsigned) oldVal;
};

int spaces_chunk_set_page_resizing(SpacesChunk chunk, int val)
{
    Bool oldVal;

    {
        if (!(chunk)) {
            (chunk) = (spaces_default_chunk = spaces_init_default_chunk());
        }
    };
    {
        if ((chunk)->flags & 0x8000u) {
            ThreadID tid_ = pthread_self();
            ThreadLocalChunk *tlp_ = &spaces__threadLocalChunks[tid_ % 997];
            if (tlp_->tid == tid_)
                (chunk) = tlp_->chunk;
        };
    };

    {
        if ((chunk)->smpParent)
            (chunk) = (chunk)->smpParent;
        do {
            oldVal = chunk->pageResizing;
            chunk->pageResizing = (unsigned short) val;
            if (val)
                chunk->minPageSize =
                    (0x00010000lu -
                     ((PageSize)
                      ((PageSize) ((PageSize) (sizeof(Area)) + (PageSize) ((sizeof(double)) - 1u)) &
                       ((PageSize) (~((PageSize) ((sizeof(double)) - 1u)))))));
            else
                chunk->minPageSize = chunk->pageSize;
        } while (((chunk) = (chunk)->smpNextChunk) != 0 && (chunk) != (chunk)->smpParent);
    }
    return oldVal;
};

static unsigned _spaces__normalizePageSize(unsigned size)
{
    if (size >=
        (0x00010000lu -
         ((PageSize)
          ((PageSize) ((PageSize) (sizeof(Area)) + (PageSize) ((sizeof(double)) - 1u)) &
           ((PageSize) (~((PageSize) ((sizeof(double)) - 1u))))))))
        return (unsigned) (0x00010000lu -
                           ((PageSize)
                            ((PageSize) ((PageSize) (sizeof(Area)) + (PageSize) ((sizeof(double)) - 1u)) &
                             ((PageSize) (~((PageSize) ((sizeof(double)) - 1u)))))));
    else {
        unsigned power2 = (unsigned) 0x00010000lu;

        while (size > power2)
            if ((PageSize) (power2 += power2) == (PageSize) 0)
                return (unsigned) (0x00010000lu -
                                   ((PageSize)
                                    ((PageSize) ((PageSize) (sizeof(Area)) + (PageSize) ((sizeof(double)) - 1u)) &
                                     ((PageSize) (~((PageSize) ((sizeof(double)) - 1u)))))));

        return (power2 >
                (0x00010000lu -
                 ((PageSize)
                  ((PageSize) ((PageSize) (sizeof(Area)) + (PageSize) ((sizeof(double)) - 1u)) &
                   ((PageSize) (~((PageSize) ((sizeof(double)) - 1u))))))))
            ? (0x00010000lu -
               ((PageSize)
                ((PageSize) ((PageSize) (sizeof(Area)) + (PageSize) ((sizeof(double)) - 1u)) &
                 ((PageSize) (~((PageSize) ((sizeof(double)) - 1u))))))) : power2 -
            ((PageSize)
             ((PageSize) ((PageSize) (sizeof(Area)) + (PageSize) ((sizeof(double)) - 1u)) &
              ((PageSize) (~((PageSize) ((sizeof(double)) - 1u))))));
    }
};

Bool spaces_chunk_set_block_size(Chunk * chunk, unsigned short blockSize)
{
    unsigned alignedBlockSize;
    Bool result;

    alignedBlockSize =
        blockSize
        ? ((PageSize)
           ((PageSize) ((PageSize) (blockSize + 0) + (PageSize) ((sizeof(double)) - 1u)) &
            ((PageSize) (~((PageSize) ((sizeof(double)) - 1u)))))) - 0 : 0;

    {
        if (!(chunk)) {
            (chunk) = (spaces_default_chunk = spaces_init_default_chunk());
        }
    };
    {
        if ((chunk)->flags & 0x8000u) {
            ThreadID tid_ = pthread_self();
            ThreadLocalChunk *tlp_ = &spaces__threadLocalChunks[tid_ % 997];
            if (tlp_->tid == tid_)
                (chunk) = tlp_->chunk;
        };
    };

    {
        if ((chunk)->smpParent)
            (chunk) = (chunk)->smpParent;
        do { {
                if ((chunk)->flags & 0x0002u) {
                    if ((chunk)->flags & 0x0001u) {
                        if (!_spaces__lockSharedSem(chunk))
                            return 0;
                    } else { {
                            if (!(pthread_mutex_lock(&(&((chunk)->mutex))->m) == 0 && ++(&((chunk)->mutex))->count))
                                return 0;
                            if ((chunk)->mutex.count == 1) {
                                if (((chunk)->flags & 0x0002u)) { {
                                        int i___ = 2;
                                        int k___ = 0;
                                        while (!((((chunk)->lock) && spaces__test_and_clear(&(chunk)->lock)))) {;
                                            if (i___-- == 0) {
                                                spaces__smpYield(k___++);
                                                i___ = 2;
                                            }
                                        }
                                }
                                };
                            }
                    };
                    }
                }
        };
        if (alignedBlockSize < blockSize
            || alignedBlockSize >
            (PageSize) (chunk->pageSize -
                        ((PageSize)
                         ((PageSize) ((PageSize) (sizeof(Page) + (0)) + (PageSize) ((sizeof(double)) - 1u)) &
                          ((PageSize) (~((PageSize) ((sizeof(double)) - 1u))))))) || alignedBlockSize > (0x7fff * 2 + 1)
            ) {
            _spaces__invokeErrorHandler1(chunk, SPACES_ERR_BLOCK_TOO_BIG);
            result = 0;
        } else if (chunk->rovers[((PageType) 1)] == 0) {
            chunk->blockSizeFS = (unsigned short) alignedBlockSize;
            result = 1;
        } else
            result = 0;
        {
            if ((chunk)->flags & 0x0002u) {
                if ((chunk)->flags & 0x0001u)
                    _spaces__unlockSharedSem(chunk);
                else { {
                        if ((chunk)->mutex.count == 1) { {
                                if (((chunk)->flags & 0x0002u) && !(chunk)->locktid) {
                                    if (!spaces__preForkLock) { {
                                            if ((chunk)->smpFreeQueue)
                                                spaces__smpFlushQueue(chunk);
                                    };
                                    }
                                    ((chunk)->lock = 1);
                                }
                        };
                        }
                        (--(&((chunk)->mutex))->count, pthread_mutex_unlock(&(&((chunk)->mutex))->m));
                };
                }
            }
        };
        } while (((chunk) = (chunk)->smpNextChunk) != 0 && (chunk) != (chunk)->smpParent);
    }
    return result;
};

Bool spaces_chunk_set_small_block_size(Chunk * chunk, unsigned short blockSize)
{
    Bool result;


    {
        if (!(chunk)) {
            (chunk) = (spaces_default_chunk = spaces_init_default_chunk());
        }
    };
    {
        if ((chunk)->flags & 0x8000u) {
            ThreadID tid_ = pthread_self();
            ThreadLocalChunk *tlp_ = &spaces__threadLocalChunks[tid_ % 997];
            if (tlp_->tid == tid_)
                (chunk) = tlp_->chunk;
        };
    };

    {
        if ((chunk)->smpParent)
            (chunk) = (chunk)->smpParent;
        do { {
                if ((chunk)->flags & 0x0002u) {
                    if ((chunk)->flags & 0x0001u) {
                        if (!_spaces__lockSharedSem(chunk))
                            return 0;
                    } else { {
                            if (!(pthread_mutex_lock(&(&((chunk)->mutex))->m) == 0 && ++(&((chunk)->mutex))->count))
                                return 0;
                            if ((chunk)->mutex.count == 1) {
                                if (((chunk)->flags & 0x0002u)) { {
                                        int i___ = 2;
                                        int k___ = 0;
                                        while (!((((chunk)->lock) && spaces__test_and_clear(&(chunk)->lock)))) {;
                                            if (i___-- == 0) {
                                                spaces__smpYield(k___++);
                                                i___ = 2;
                                            }
                                        }
                                }
                                };
                            }
                    };
                    }
                }
        };
        if (blockSize > 2048) {
            _spaces__invokeErrorHandler1(chunk, SPACES_ERR_BLOCK_TOO_BIG);
            result = 0;
        } else {
            chunk->smallSize = (unsigned short) blockSize;
            result = 1;
        } {
            if ((chunk)->flags & 0x0002u) {
                if ((chunk)->flags & 0x0001u)
                    _spaces__unlockSharedSem(chunk);
                else { {
                        if ((chunk)->mutex.count == 1) { {
                                if (((chunk)->flags & 0x0002u) && !(chunk)->locktid) {
                                    if (!spaces__preForkLock) { {
                                            if ((chunk)->smpFreeQueue)
                                                spaces__smpFlushQueue(chunk);
                                    };
                                    }
                                    ((chunk)->lock = 1);
                                }
                        };
                        }
                        (--(&((chunk)->mutex))->count, pthread_mutex_unlock(&(&((chunk)->mutex))->m));
                };
                }
            }
        };
        } while (((chunk) = (chunk)->smpNextChunk) != 0 && (chunk) != (chunk)->smpParent);
    }
    return result;
};

size_t spaces_chunk_set_floor(Chunk * chunk, size_t floor)
{
    size_t oldFloor;

    {
        if (!(chunk)) {
            (chunk) = (spaces_default_chunk = spaces_init_default_chunk());
        }
    };
    {
        if ((chunk)->flags & 0x8000u) {
            ThreadID tid_ = pthread_self();
            ThreadLocalChunk *tlp_ = &spaces__threadLocalChunks[tid_ % 997];
            if (tlp_->tid == tid_)
                (chunk) = tlp_->chunk;
        };
    };

    {
        if ((chunk)->smpParent)
            (chunk) = (chunk)->smpParent;
        do { {
                if ((chunk)->flags & 0x0002u) {
                    if ((chunk)->flags & 0x0001u) {
                        if (!_spaces__lockSharedSem(chunk))
                            return (size_t) (-1);
                    } else { {
                            if (!(pthread_mutex_lock(&(&((chunk)->mutex))->m) == 0 && ++(&((chunk)->mutex))->count))
                                return (size_t) (-1);
                            if ((chunk)->mutex.count == 1) {
                                if (((chunk)->flags & 0x0002u)) { {
                                        int i___ = 2;
                                        int k___ = 0;
                                        while (!((((chunk)->lock) && spaces__test_and_clear(&(chunk)->lock)))) {;
                                            if (i___-- == 0) {
                                                spaces__smpYield(k___++);
                                                i___ = 2;
                                            }
                                        }
                                }
                                };
                            }
                    };
                    }
                }
        };
        if (floor > chunk->ceiling)
            oldFloor = (size_t) (-1);
        else {
            oldFloor = chunk->floor;
            chunk->floor = floor == (size_t) (-1) ? (size_t) (-1) - 1 : floor;
        } {
            if ((chunk)->flags & 0x0002u) {
                if ((chunk)->flags & 0x0001u)
                    _spaces__unlockSharedSem(chunk);
                else { {
                        if ((chunk)->mutex.count == 1) { {
                                if (((chunk)->flags & 0x0002u) && !(chunk)->locktid) {
                                    if (!spaces__preForkLock) { {
                                            if ((chunk)->smpFreeQueue)
                                                spaces__smpFlushQueue(chunk);
                                    };
                                    }
                                    ((chunk)->lock = 1);
                                }
                        };
                        }
                        (--(&((chunk)->mutex))->count, pthread_mutex_unlock(&(&((chunk)->mutex))->m));
                };
                }
            }
        };
        } while (((chunk) = (chunk)->smpNextChunk) != 0 && (chunk) != (chunk)->smpParent);
    }
    return oldFloor;
};

unsigned spaces__normalizeGrowIncrement(size_t size)
{
    if (size >=
        (0x00010000lu -
         ((PageSize)
          ((PageSize) ((PageSize) (sizeof(Area)) + (PageSize) ((sizeof(double)) - 1u)) &
           ((PageSize) (~((PageSize) ((sizeof(double)) - 1u))))))))
        return (unsigned) (0x00010000lu -
                           ((PageSize)
                            ((PageSize) ((PageSize) (sizeof(Area)) + (PageSize) ((sizeof(double)) - 1u)) &
                             ((PageSize) (~((PageSize) ((sizeof(double)) - 1u)))))));
    else {
        unsigned power2 = (unsigned) 0x00010000lu;

        while (size > power2)
            if ((PageSize) (power2 += power2) == (PageSize) 0)
                return (unsigned) (0x00010000lu -
                                   ((PageSize)
                                    ((PageSize) ((PageSize) (sizeof(Area)) + (PageSize) ((sizeof(double)) - 1u)) &
                                     ((PageSize) (~((PageSize) ((sizeof(double)) - 1u)))))));

        return (power2 >
                (0x00010000lu -
                 ((PageSize)
                  ((PageSize) ((PageSize) (sizeof(Area)) + (PageSize) ((sizeof(double)) - 1u)) &
                   ((PageSize) (~((PageSize) ((sizeof(double)) - 1u))))))))
            ? (0x00010000lu -
               ((PageSize)
                ((PageSize) ((PageSize) (sizeof(Area)) + (PageSize) ((sizeof(double)) - 1u)) &
                 ((PageSize) (~((PageSize) ((sizeof(double)) - 1u))))))) : power2 -
            ((PageSize)
             ((PageSize) ((PageSize) (sizeof(Area)) + (PageSize) ((sizeof(double)) - 1u)) &
              ((PageSize) (~((PageSize) ((sizeof(double)) - 1u))))));
    }
};

size_t spaces_chunk_set_grow_increment(Chunk * chunk, size_t grow)
{
    size_t oldGrow;

    {
        if (!(chunk)) {
            (chunk) = (spaces_default_chunk = spaces_init_default_chunk());
        }
    };
    {
        if ((chunk)->flags & 0x8000u) {
            ThreadID tid_ = pthread_self();
            ThreadLocalChunk *tlp_ = &spaces__threadLocalChunks[tid_ % 997];
            if (tlp_->tid == tid_)
                (chunk) = tlp_->chunk;
        };
    };

    {
        if ((chunk)->smpParent)
            (chunk) = (chunk)->smpParent;
        do {
            oldGrow = chunk->growIncrement;
            chunk->growIncrement = grow;
            chunk->flags |= 0x00040000u;
        } while (((chunk) = (chunk)->smpNextChunk) != 0 && (chunk) != (chunk)->smpParent);
    }

    return oldGrow;
};

size_t spaces_chunk_set_free_bytes(Chunk * chunk, size_t bytes)
{
    size_t old;

    {
        if (!(chunk)) {
            (chunk) = (spaces_default_chunk = spaces_init_default_chunk());
        }
    };
    {
        if ((chunk)->flags & 0x8000u) {
            ThreadID tid_ = pthread_self();
            ThreadLocalChunk *tlp_ = &spaces__threadLocalChunks[tid_ % 997];
            if (tlp_->tid == tid_)
                (chunk) = tlp_->chunk;
        };
    };

    {
        if ((chunk)->smpParent)
            (chunk) = (chunk)->smpParent;
        do {
            old = chunk->freeBytes;
            chunk->freeBytes = bytes;
            chunk->flags |= 0x00080000u;
        } while (((chunk) = (chunk)->smpNextChunk) != 0 && (chunk) != (chunk)->smpParent);
    }

    return old;
};

int spaces_chunk_set_serialization(Chunk * chunk, int bSerialize)
{
    int old = 1;

    {
        if (!(chunk)) {
            (chunk) = (spaces_default_chunk = spaces_init_default_chunk());
        }
    };

    (void) bSerialize;

    return old;
};

static Bool spaces__MDefaultChunkThreadExclusive(unsigned flags, ThreadID tid);

int spaces_default_chunk_thread_exclusive(unsigned flags)
{
    return spaces__MDefaultChunkThreadExclusive(flags, 0);
};

Bool spaces__MDefaultChunkThreadExclusive(unsigned flags, ThreadID tid)
{

    SpacesChunk chunk = 0, defChunk = spaces_default_chunk ? spaces_default_chunk : spaces_init_default_chunk();
    Bool createdChunk = 0;
    TaskRecord *taskRec = (&_spaces__TaskRecord);
    Bool bExclusive = flags & SPACES_THREAD_EXCLUSIVE_ON;
    Bool bFreeOnThreadTerm = flags & SPACES_FREE_ON_THREAD_TERM;
    Bool bResult = 0, bWasExclusive = 0;


    if (!tid)
        tid = pthread_self();

    if (bFreeOnThreadTerm && !bExclusive) {
        _spaces__invokeErrorHandler1(chunk, SPACES_ERR_BAD_FLAGS);
        return 0;
    }

    {
        if (!spaces__createAndEnterMutex(&spaces__mutexGlobal))
            return 0;
    };

    for (chunk = taskRec->chunks; chunk;
         chunk = (*(((chunk)->flags & 0x0001u) ? _spaces__getNextChunk(chunk) : &((chunk)->task.private_.next)))) {
        if ((chunk->flags & 0x00010000u)
            && chunk->smpThreadID == tid)
            break;
    }

    {
        if (!spaces__preInitThreads)
            (--(&spaces__mutexGlobal)->count, pthread_mutex_unlock(&(&spaces__mutexGlobal)->m));
    };

    if (chunk) {
        if (!bExclusive) {

            chunk->flags &= ~0x00010000u;
            chunk->flags &= ~0x00020000u;
            bFreeOnThreadTerm = 0;

            chunk->flags |= 0x0002u;

            spaces__insertSubChunk(chunk, defChunk, 0);

            return 1;
        } else {

            bWasExclusive = 1;

            if (!bFreeOnThreadTerm)
                chunk->flags &= ~0x00020000u;
            else
                chunk->flags |= 0x00020000u;
        }
    }

    {
        if (!(pthread_mutex_lock(&(&spaces__mutexSMP)->m) == 0 && ++(&spaces__mutexSMP)->count))
            return 0;
    };

    if (!bExclusive) {
        spaces__setThreadLocalChunk(0, 0);
        chunk = 0;
        bResult = 1;
    } else if (!chunk) {

        unsigned flags = 0;

        if (bFreeOnThreadTerm)
            flags |= 0x00020000u;

        if (bExclusive)
            flags |= 0x00010000u;

        chunk = spaces__initSubChunk(defChunk, flags);

        if (chunk) {
            createdChunk = 1;

            chunk->subChunkPosition = 0;
        }
    }

    if (chunk && !bWasExclusive) {
        if (bExclusive)
            chunk->flags &= ~0x0002u;

        if (spaces__setThreadLocalChunk(chunk, bExclusive))
            bResult = 1;
    } else if (chunk && bWasExclusive) {

        bResult = 1;
    }

    (--(&spaces__mutexSMP)->count, pthread_mutex_unlock(&(&spaces__mutexSMP)->m));

    if (!bResult && createdChunk)
        _spaces__chunkFree(chunk, 0);

    return bResult;

};

void spaces__freeThreadExcChunk(Chunk * chunk, SpacesThreadId tid)
{

    if (!chunk) {
        {
            ThreadID tid_ = pthread_self();
            ThreadLocalChunk *tlp_ = &spaces__threadLocalChunks[tid_ % 997];
            if (tlp_->tid == tid_)
                (chunk) = tlp_->chunk;
        };
    }

    if (chunk) {

        if (chunk->flags & 0x00020000u) {

            chunk->flags &= ~0x00010000u;

            if (!tid) {
                {
                    if (!(pthread_mutex_lock(&(&spaces__mutexSMP)->m) == 0 && ++(&spaces__mutexSMP)->count))
                        return;
                };
                spaces__setThreadLocalChunk(0, 0);
                (--(&spaces__mutexSMP)->count, pthread_mutex_unlock(&(&spaces__mutexSMP)->m));
            }

            _spaces__chunkFree(chunk, 0);
        } else if (chunk->flags & 0x00010000u) {

            spaces__MDefaultChunkThreadExclusive(SPACES_THREAD_EXCLUSIVE_OFF, tid);
        }
    }

};

size_t spaces_chunk_set_ceiling(Chunk * chunk, size_t ceil)
{
    size_t oldCeil;

    {
        if (!(chunk)) {
            (chunk) = (spaces_default_chunk = spaces_init_default_chunk());
        }
    };
    {
        if ((chunk)->flags & 0x8000u) {
            ThreadID tid_ = pthread_self();
            ThreadLocalChunk *tlp_ = &spaces__threadLocalChunks[tid_ % 997];
            if (tlp_->tid == tid_)
                (chunk) = tlp_->chunk;
        };
    };

    {
        if ((chunk)->smpParent)
            (chunk) = (chunk)->smpParent;
        do { {
                if ((chunk)->flags & 0x0002u) {
                    if ((chunk)->flags & 0x0001u) {
                        if (!_spaces__lockSharedSem(chunk))
                            return (size_t) (-1);
                    } else { {
                            if (!(pthread_mutex_lock(&(&((chunk)->mutex))->m) == 0 && ++(&((chunk)->mutex))->count))
                                return (size_t) (-1);
                            if ((chunk)->mutex.count == 1) {
                                if (((chunk)->flags & 0x0002u)) { {
                                        int i___ = 2;
                                        int k___ = 0;
                                        while (!((((chunk)->lock) && spaces__test_and_clear(&(chunk)->lock)))) {;
                                            if (i___-- == 0) {
                                                spaces__smpYield(k___++);
                                                i___ = 2;
                                            }
                                        }
                                }
                                };
                            }
                    };
                    }
                }
        };
        if (ceil < chunk->floor || ceil < chunk->pageTotal)
            oldCeil = (size_t) (-1);
        else {
            oldCeil = chunk->ceiling;
            chunk->ceiling = ceil == (size_t) (-1) ? (size_t) (-1) - 1 : ceil;
        } {
            if ((chunk)->flags & 0x0002u) {
                if ((chunk)->flags & 0x0001u)
                    _spaces__unlockSharedSem(chunk);
                else { {
                        if ((chunk)->mutex.count == 1) { {
                                if (((chunk)->flags & 0x0002u) && !(chunk)->locktid) {
                                    if (!spaces__preForkLock) { {
                                            if ((chunk)->smpFreeQueue)
                                                spaces__smpFlushQueue(chunk);
                                    };
                                    }
                                    ((chunk)->lock = 1);
                                }
                        };
                        }
                        (--(&((chunk)->mutex))->count, pthread_mutex_unlock(&(&((chunk)->mutex))->m));
                };
                }
            }
        };
        } while (((chunk) = (chunk)->smpNextChunk) != 0 && (chunk) != (chunk)->smpParent);
    }
    return oldCeil;
};

Bool spaces_chunk_destroy(Chunk * chunk)
{

    {
        if (!(chunk)) {
            (chunk) = (spaces_default_chunk = spaces_init_default_chunk());
        }
    };

    return _spaces__chunkFree(chunk, 0);
};

SpacesChunk _spaces__chunkTerminating = 0;

Bool _spaces__chunkFree(Chunk * chunk, Bool bTerminating)
{
    Bool bFinalFree = 1;
    (void)bTerminating;

    {
        SpacesChunk nextChunk, parentChunk = chunk->smpParent;

        if (parentChunk)
            chunk = parentChunk;
        else
            parentChunk = chunk;

        if (chunk->flags & (0x0001u | 0x0010u)) {

            nextChunk = parentChunk;
            while ((nextChunk = nextChunk->smpNextChunk) != parentChunk)
                _spaces__taskRemoveChunk(nextChunk);
        }

        do {
            nextChunk = chunk->smpNextChunk;

            _spaces__chunkTerminating = chunk;

            {
                if (!spaces__createAndEnterMutex(&spaces__mutexGlobal))
                    return 0;
            };

            if (chunk->flags & (0x0001u | 0x0010u)) {
                bFinalFree = _spaces__unregisterShared(chunk, 0) == 0;

                _spaces__chunkTerminating = 0;
                {
                    if (!spaces__preInitThreads)
                        (--(&spaces__mutexGlobal)->count, pthread_mutex_unlock(&(&spaces__mutexGlobal)->m));
                };
                goto out;

            } else
                _spaces__taskRemoveChunk(chunk);

            if (bFinalFree)
                chunk->signature = 0;

            {
                PageHeader *rover;
                PageType i;

                for (i = 0; i < ((PageType) 7); i++)
                    if ((rover = chunk->rovers[i]) != 0)
                        do {
                            if (bFinalFree)
                                rover->page->flagsAndSignature = 0;

                            _spaces__sysFree(rover->page);
                        }
                        while ((rover = rover->next) != chunk->rovers[i]);
            }

            {
                register PageHdrStorage *page = chunk->extraPages, *next;
                while (page) {
                    next = page->next;
                    _spaces__sysFree(page);
                    page = next;
                }
            }

            {
                if ((chunk)->flags & 0x0002u)
                    pthread_mutex_destroy(&((chunk)->mutex.m));
            };

            _spaces__chunkTerminating = 0;

            {
                if (!spaces__preInitThreads)
                    (--(&spaces__mutexGlobal)->count, pthread_mutex_unlock(&(&spaces__mutexGlobal)->m));
            };

            _spaces__sysFree(chunk);

        }
        while ((chunk = nextChunk) != parentChunk);
    }

  out:


    return 1;
};

Bool spaces_chunk_lock(Chunk * chunk)
{
    {
        if (!(chunk)) {
            (chunk) = (spaces_default_chunk = spaces_init_default_chunk());
        }
    };

    {
        if (!(pthread_mutex_lock(&(&spaces__mutexSMP)->m) == 0 && ++(&spaces__mutexSMP)->count))
            return 0;
    };

    {
        if ((chunk)->smpParent)
            (chunk) = (chunk)->smpParent;
        do { {
                if ((chunk)->flags & 0x0002u) {
                    if ((chunk)->flags & 0x0001u) {
                        if (!_spaces__lockSharedSem(chunk))
                            return 0;
                    } else { {
                            if (!(pthread_mutex_lock(&(&((chunk)->mutex))->m) == 0 && ++(&((chunk)->mutex))->count))
                                return 0;
                            if ((chunk)->mutex.count == 1) {
                                if (((chunk)->flags & 0x0002u)) { {
                                        int i___ = 2;
                                        int k___ = 0;
                                        while (!((((chunk)->lock) && spaces__test_and_clear(&(chunk)->lock)))) {;
                                            if (i___-- == 0) {
                                                spaces__smpYield(k___++);
                                                i___ = 2;
                                            }
                                        }
                                }
                                };
                            }
                    };
                    }
                }
        };
        } while (((chunk) = (chunk)->smpNextChunk) != 0 && (chunk) != (chunk)->smpParent);
    }

    return 1;
};

Bool spaces_chunk_unlock(Chunk * chunk)
{
    {
        if (!(chunk)) {
            (chunk) = (spaces_default_chunk = spaces_init_default_chunk());
        }
    };

    if (((chunk)->mutex.count) == 0)
        return 0;

    {
        if ((chunk)->smpParent)
            (chunk) = (chunk)->smpParent;
        do { {
                if ((chunk)->flags & 0x0002u) {
                    if ((chunk)->flags & 0x0001u)
                        _spaces__unlockSharedSem(chunk);
                    else { {
                            if ((chunk)->mutex.count == 1) { {
                                    if (((chunk)->flags & 0x0002u) && !(chunk)->locktid) {
                                        if (!spaces__preForkLock) { {
                                                if ((chunk)->smpFreeQueue)
                                                    spaces__smpFlushQueue(chunk);
                                        };
                                        }
                                        ((chunk)->lock = 1);
                                    }
                            };
                            }
                            (--(&((chunk)->mutex))->count, pthread_mutex_unlock(&(&((chunk)->mutex))->m));
                    };
                    }
                }
        };
        } while (((chunk) = (chunk)->smpNextChunk) != 0 && (chunk) != (chunk)->smpParent);
    }

    (--(&spaces__mutexSMP)->count, pthread_mutex_unlock(&(&spaces__mutexSMP)->m));

    return 1;
};
static FreeArea spaces__freeAreaSentinel = { 0, &spaces__freeAreaSentinel, &spaces__freeAreaSentinel, 0 };

static FreeArea *spaces__freeAreas = &spaces__freeAreaSentinel, *spaces__freeFreeAreas = 0;
typedef struct _FreeAreaAlloc {
    struct _FreeAreaAlloc *next;
    size_t size;
} FreeAreaAlloc;
static FreeAreaAlloc *spaces__freeAreaAllocs = 0;
static TailArea spaces__tailAreaSentinel = { 0, &spaces__tailAreaSentinel, &spaces__tailAreaSentinel, 0 };

static TailArea *spaces__tailAreas = &spaces__tailAreaSentinel;

static size_t spaces__processHeapLimit = (0x7fffffffffffffffL * 2UL + 1UL);
static size_t spaces__processLargeBlockThreshold = 32 * 1024L * 1024L;

static size_t spaces__processGrowIncrement = (1 * 1024L * 1024L);
static Bool spaces__processGrowIncrementOverride = 0;

static size_t spaces__processFreeBytes = (4 * 1024L * 1024L);
static Bool spaces__processFreeBytesOverride = 0;

size_t spaces__sysHeapTotal = 0;
static size_t spaces__sysTotalFree = 0;
Bool spaces__munmapEnabled = 0;
static Bool spaces__coelesceTailAreas = 1;

unsigned long spaces__pageSize = 0;

static void *spaces__sysAllocChunk1(Chunk * chunk, FreeArea **, size_t size, unsigned flags, Bool bUseParmFreeArea);
static FreeArea *spaces__allocFreeArea(Chunk * chunk, Area * area, size_t size);
static TailArea *spaces__allocTailArea(Chunk * chunk, Area * area, size_t size);
static FreeArea *spaces__allocFreeArea1(Chunk * chunk, Area * area,
                                        size_t size, FreeArea ** head, FreeArea ** freelist);
static void spaces__freeFreeArea(Chunk *, FreeArea *);
static void spaces__freeTailArea(Chunk *, TailArea *);
static void spaces__freeFreeArea1(Chunk *, FreeArea *, FreeArea ** head, FreeArea ** freelist);

static FreeArea *spaces__growSystemHeap(Chunk * chunk, void *addr, TailArea *, size_t size, unsigned flags);
static void spaces__shrinkSystemHeap(Chunk * chunk, Bool bFlush);
static Bool spaces__pageOutArea(Chunk * chunk, Area * area, size_t size, Bool bAdjustTotalFree);
static Bool spaces__pageInArea(Area * area, size_t commitSize, size_t size, Bool bAdjustTotalFree);
static void spaces__shrinkAddressSpace(Chunk * chunk, FreeArea * freeArea);
static void spaces__flushAreas(void);
static void spaces__flushFreeAreas(void);
static size_t spaces__sumFreeAreas(void);

int spaces_process_info(SpacesProcessInfo * info)
{
    if (!_spaces__sysValidatePtr(info, sizeof(SpacesProcessInfo), 0))
        return 0;

    info->growIncrement = spaces__processGrowIncrement;
    info->freeBytes = spaces__processFreeBytes;
    info->largeBlockThreshold = spaces__processLargeBlockThreshold;
    info->heapLimit = spaces__processHeapLimit;
    info->heapTotal = spaces__sysHeapTotal;
    info->totalFree = spaces__sysTotalFree;
    info->useMunmap = spaces__munmapEnabled;
    info->coelesceSystemAllocs = spaces__coelesceTailAreas;

    return 1;
};

size_t spaces_process_set_grow_increment(size_t size)
{
    size_t old = spaces__processGrowIncrement;

    size_t power2 = 0x00010000lu;

    while (size > power2) {
        if ((power2 += power2) == 0) {

            power2 >>= 1;
            break;
        }
    }

    spaces__processGrowIncrement = power2;

    spaces__processGrowIncrementOverride = 1;

    return old;
};

size_t spaces_process_set_free_bytes(size_t size)
{
    size_t old = spaces__processFreeBytes;

    spaces__processFreeBytes =
        ((unsigned long) ((unsigned long) ((unsigned long) ((size)) + (unsigned long) ((0x10000) - 1u)) &
                          ((unsigned long) (~((unsigned long) ((0x10000) - 1u))))));

    if (spaces__processFreeBytes < size)
        spaces__processFreeBytes = (0x7fffffffffffffffL * 2UL + 1UL);

    spaces__processFreeBytesOverride = 1;

    return old;
};

size_t spaces_process_set_large_threshold(size_t size)
{
    size_t old = spaces__processLargeBlockThreshold;

    spaces__processLargeBlockThreshold =
        ((unsigned long) ((unsigned long) ((unsigned long) ((size)) + (unsigned long) ((0x10000) - 1u)) &
                          ((unsigned long) (~((unsigned long) ((0x10000) - 1u))))));

    if (spaces__processLargeBlockThreshold < size)
        spaces__processLargeBlockThreshold = (0x7fffffffffffffffL * 2UL + 1UL);

    return old;
};

size_t spaces_process_set_heap_limit(size_t size)
{
    size_t old = spaces__processHeapLimit;

    spaces__processHeapLimit = size;

    return old;
};

int spaces_process_use_munmap(int bMunmap)
{
    int old = spaces__munmapEnabled;

    spaces__munmapEnabled = bMunmap;

    return old;
};

int spaces_process_coalesce_allocs(int bValue)
{
    int old = spaces__coelesceTailAreas;

    spaces__coelesceTailAreas = bValue;

    return old;
};

void spaces_process_flush_all()
{
    spaces__shrinkSystemHeap(0, 1);

    if (spaces__sysHeapTotal - spaces__sysTotalFree == spaces__sumFreeAreas()) {

        spaces__flushAreas();
        spaces__flushFreeAreas();

        spaces__sysHeapTotal = spaces__sysTotalFree = 0;
    }
};

void *_spaces__sysAlloc(size_t size, unsigned flags)
{
    return _spaces__sysAllocChunk(0, size, flags);
};

void *_spaces__sysAllocChunk(Chunk * chunk, size_t size, unsigned flags)
{
    FreeArea **area;
    void *result;

    {
        if (!spaces__createAndEnterMutex(&spaces__mutexGlobal))
            return 0;
    };

    if (flags & (0x0001u | 0x0010u)) {
        if (!chunk) {
            {
                if (!spaces__preInitThreads)
                    (--(&spaces__mutexGlobal)->count, pthread_mutex_unlock(&(&spaces__mutexGlobal)->m));
            };
            _spaces__invokeErrorHandler1(0, SPACES_ERR_BAD_FLAGS);
            return 0;
        }

        chunk = chunk->smpParent;

        area = &chunk->freeAreas;
    } else {
        chunk = 0;
        area = &spaces__freeAreas;
    }

    result = spaces__sysAllocChunk1(chunk, area, size, flags, 0);

    {
        if (!spaces__preInitThreads)
            (--(&spaces__mutexGlobal)->count, pthread_mutex_unlock(&(&spaces__mutexGlobal)->m));
    };

    return result;
};

static void *spaces__sysAllocChunk1(Chunk * chunk, FreeArea ** head, size_t size, unsigned flags, Bool bUseParmFreeArea)
{
    Area *result = 0;
    size_t size64;
    size_t reqSize; (void)reqSize;
    if ((flags & 0x1000u)
        && size >
        (0x00010000lu -
         ((PageSize)
          ((PageSize) ((PageSize) (sizeof(Area)) + (PageSize) ((sizeof(double)) - 1u)) &
           ((PageSize) (~((PageSize) ((sizeof(double)) - 1u))))))))
        size =
            (0x00010000lu -
             ((PageSize)
              ((PageSize) ((PageSize) (sizeof(Area)) + (PageSize) ((sizeof(double)) - 1u)) &
               ((PageSize) (~((PageSize) ((sizeof(double)) - 1u)))))));

    if (flags & 0x00100000u) {

        if (flags & 0x2000u)
            size +=
                ((PageSize)
                 ((PageSize) ((PageSize) (sizeof(Area)) + (PageSize) ((sizeof(double)) - 1u)) &
                  ((PageSize) (~((PageSize) ((sizeof(double)) - 1u))))));
        size =
            (((unsigned long) ((unsigned long) ((unsigned long) ((size)) + (unsigned long) ((0x10000) - 1u)) &
                               ((unsigned long) (~((unsigned long) ((0x10000) - 1u)))))) -
             ((PageSize)
              ((PageSize) ((PageSize) (sizeof(Area)) + (PageSize) ((sizeof(double)) - 1u)) &
               ((PageSize) (~((PageSize) ((sizeof(double)) - 1u)))))));
    }

    reqSize = size;

    size +=
        ((PageSize)
         ((PageSize) ((PageSize) (sizeof(Area)) + (PageSize) ((sizeof(double)) - 1u)) &
          ((PageSize) (~((PageSize) ((sizeof(double)) - 1u))))));

    size =
        ((unsigned long) ((unsigned long) ((unsigned long) ((size)) + (unsigned long) ((0x00010000lu) - 1u)) &
                          ((unsigned long) (~((unsigned long) ((0x00010000lu) - 1u))))));
    size64 =
        ((unsigned long) ((unsigned long) ((unsigned long) ((size)) + (unsigned long) ((0x10000) - 1u)) &
                          ((unsigned long) (~((unsigned long) ((0x10000) - 1u))))));

    if ((size <= spaces__processLargeBlockThreshold || !(flags & 0x2000u))
        || bUseParmFreeArea || chunk) {
        static FreeArea worstFit = { 0, 0, 0,
            (0x7fffffffffffffffL * 2UL + 1UL)
        };
        FreeArea *freeArea = *head, *bestFit = &worstFit, *largestFree = freeArea;
        Bool bFirstFit = bUseParmFreeArea; (void)bFirstFit;

      again:
        do {
            if (freeArea->size >= size) {

                bestFit = freeArea;
                break;
            } else if (freeArea->size > largestFree->size)
                largestFree = freeArea;
        }
        while ((freeArea = freeArea->next) != *head);

        if (bestFit->area) {
            if (bestFit->area->commitSize < size
                && !spaces__pageInArea(bestFit->area, bestFit->area->commitSize, size, 1)) {
                freeArea = bestFit->next;

                bFirstFit = 1;
                bestFit = &worstFit;
                if (freeArea == *head)
                    freeArea = 0;
                else
                    goto again;
            } else
                freeArea = bestFit;
        } else if ((flags & 0x00100000u)
                   && largestFree->size >= (64 * 1024L)) {

            freeArea = largestFree;
        } else
            freeArea = 0;

        if (!freeArea) {

            if (!result)
                freeArea = spaces__growSystemHeap(chunk, 0, 0, size64, flags & ~0x2000u & ~0x0100u);
        }

        if ((flags & (0x00100000u | 0x1000u))
            && !(flags & 0x2000u)) {

            if (!freeArea && largestFree->size >= 0x00010000lu) {

                freeArea = largestFree;
            }

            if (freeArea) {
                size = (((size) < (freeArea->size)) ? (size) : (freeArea->size));
                size64 =
                    ((unsigned long) ((unsigned long) ((unsigned long) ((size)) + (unsigned long) ((0x10000) - 1u)) &
                                      ((unsigned long) (~((unsigned long) ((0x10000) - 1u))))));

                if (freeArea->area->commitSize < size) {

                    while (!spaces__pageInArea(freeArea->area, freeArea->area->commitSize, size, 1)) {
                        if ((size >>= 1) < 0x00010000lu)
                            break;
                    }

                    if (size >= 0x00010000lu)
                        size64 =
                            ((unsigned
                              long) ((unsigned long) ((unsigned long) ((size)) +
                                                      (unsigned long) ((0x10000) -
                                                                       1u)) & ((unsigned
                                                                                long) (~((unsigned long) ((0x10000) -
                                                                                                          1u))))));
                    else
                        freeArea = 0;
                }
            }
        }

        if (freeArea) {

            Area *nextArea;
            size_t commitSize = freeArea->area->commitSize;

            result = freeArea->area;
            ((result)->sizeOrFree.freeArea = 0, (result)->sizeOrFree.inUseSize = (size64) | 1ul);
            result->commitSize = (((commitSize) < (size64)) ? (commitSize) : (size64));

            nextArea = ((result)->tailArea ? 0 : ((Area *) ((char *) (result) + (freeArea->size))));
            if (nextArea)
                nextArea->prevFreeSize = freeArea->size - size64;

            if (result->commitSize > size) {
                if (!spaces__pageOutArea(chunk, result, size, 1))
                    size = result->commitSize;
            }

            nextArea = ((Area *) ((char *) (result) + (size64)));

            if (freeArea->size > size64 && (commitSize > size64 || spaces__pageInArea(nextArea, 0, 0x00010000lu, 1))) {

                freeArea->size -= size64;
                freeArea->area = nextArea;

                if (result->tailArea) {

                    {
                        (nextArea)->tailArea = (result)->tailArea;
                        (result)->tailArea = 0;
                        (nextArea)->tailArea->area = (nextArea);
                    };
                } else
                    nextArea->tailArea = 0;
                ((nextArea)->sizeOrFree.inUseSize = 0, (nextArea)->sizeOrFree.freeArea = freeArea);
                if (commitSize > size64)
                    nextArea->commitSize = commitSize - size64;
                nextArea->prevFreeSize = 0;
            } else {
                ((result)->sizeOrFree.freeArea = 0, (result)->sizeOrFree.inUseSize = (freeArea->size) | 1ul);
                spaces__freeFreeArea(chunk, freeArea);
            }

            spaces__sysTotalFree -= result->commitSize;
        }
    }

    if (!result && !chunk) {

        size_t allocSize = size64;

        if (!(flags & 0x0080u)
            && spaces__sysHeapTotal + allocSize > spaces__processHeapLimit
            && !_spaces__invokeErrorHandler1(0, SPACES_ERR_EXCEEDED_HEAP_LIMIT))
            result = 0;
        else
            result = (Area *) spaces__sysGetM(chunk, 0, size64, &allocSize, flags | 0x2000u);

        if (result) {
            ((result)->sizeOrFree.freeArea = 0, (result)->sizeOrFree.inUseSize = (allocSize) | 1ul);
            result->tailArea = 0;
            result->commitSize = allocSize;

            result->prevFreeSize = 0x0010u;

            spaces__sysHeapTotal += allocSize;
        }
    }

    if (result) {
        result++;

        if (flags & 0x0100u)
            memset(result, 0,
                   size -
                   ((PageSize)
                    ((PageSize) ((PageSize) (sizeof(Area)) + (PageSize) ((sizeof(double)) - 1u)) &
                     ((PageSize) (~((PageSize) ((sizeof(double)) - 1u)))))));
    }

    return result;
};

Bool _spaces__sysFree(void *mem)
{
    return spaces__sysFreeChunk1(0, mem, 0);
};

Bool _spaces__sysFreeChunk(Chunk * chunk, void *mem)
{
    return spaces__sysFreeChunk1(chunk, mem, 0);
};

Bool spaces__sysFreeChunk1(Chunk * chunk, void *mem, Bool bPrelocked)
{
    Bool bResult = 1;
    size_t size;
    Area *area = (Area *) mem - 1, *nextArea;
    FreeArea *freeArea = 0;
    size_t decommitSize = 0, commitBytes = area->commitSize;

    if (chunk) {
        if (chunk->flags & (0x0001u | 0x0010u)) {

            chunk = chunk->smpParent;

        } else
            chunk = 0;
    }

    if (!bPrelocked) {
        if (!spaces__createAndEnterMutex(&spaces__mutexGlobal))
            return 0;
    };

    size = ((area)->sizeOrFree.inUseSize & ~1ul);

    if (area->prevFreeSize == 0x0010u) {

        bResult = spaces__sysReturnM(chunk, area, &size, 0x2000u, 0);

        if (bResult)
            spaces__sysHeapTotal -= commitBytes;
    } else {
        spaces__sysTotalFree += commitBytes;

        nextArea = ((area)->tailArea ? 0 : ((Area *) ((char *) (area) + (size))));

        if (area->prevFreeSize) {

            Area *prevArea = ((Area *) ((char *) (area) + (-(MSIGNEDSIZET) (area->prevFreeSize))));

            freeArea = (((prevArea)->sizeOrFree.inUseSize & 1ul) ? 0 : (prevArea)->sizeOrFree.freeArea);

            commitBytes += prevArea->commitSize;

            if (prevArea->commitSize < freeArea->size) {

                decommitSize = freeArea->size + size;
            } else
                prevArea->commitSize += area->commitSize;

            size = freeArea->size += size;

            if (area->tailArea) {
                {
                    (freeArea->area)->tailArea = (area)->tailArea;
                    (area)->tailArea = 0;
                    (freeArea->area)->tailArea->area = (freeArea->area);
                };
            }
            area = freeArea->area;
        }

        if (nextArea && !((nextArea)->sizeOrFree.inUseSize & 1ul)) {

            if (decommitSize)
                decommitSize += nextArea->commitSize;
            else if (commitBytes < size) {

                decommitSize = size + nextArea->commitSize;
            } else
                area->commitSize += nextArea->commitSize;

            commitBytes += nextArea->commitSize;

            if (freeArea) {

                freeArea->size +=
                    (((nextArea)->sizeOrFree.inUseSize & 1ul) ? 0 : (nextArea)->sizeOrFree.freeArea)->size;
                spaces__freeFreeArea(chunk,
                                     (((nextArea)->sizeOrFree.inUseSize & 1ul) ? 0 : (nextArea)->sizeOrFree.freeArea));
            } else {
                freeArea = (((nextArea)->sizeOrFree.inUseSize & 1ul) ? 0 : (nextArea)->sizeOrFree.freeArea);
                freeArea->area = area;
                freeArea->size += size;
            }

            size = freeArea->size;
            if (nextArea->tailArea) {
                {
                    (area)->tailArea = (nextArea)->tailArea;
                    (nextArea)->tailArea = 0;
                    (area)->tailArea->area = (area);
                };
            }
            nextArea = ((area)->tailArea ? 0 : ((Area *) ((char *) (area) + (size))));
        }

        if (nextArea)
            nextArea->prevFreeSize = size;

        if (!freeArea) {
            freeArea = spaces__allocFreeArea(chunk, area, size);
        }

        ((area)->sizeOrFree.inUseSize = 0, (area)->sizeOrFree.freeArea = freeArea);

        if (decommitSize) {
            freeArea->area->commitSize = decommitSize;
            if (spaces__pageOutArea(chunk, freeArea->area, 0x00010000lu, 0)) {
                spaces__sysTotalFree -= (commitBytes - 0x00010000lu);

                if (decommitSize != commitBytes) {

                    spaces__sysHeapTotal += (decommitSize - 0x00010000lu);
                    spaces__sysHeapTotal -= (commitBytes - 0x00010000lu);
                }
            }

            freeArea = 0;
        }

        if (spaces__sysTotalFree > spaces__processFreeBytes)
            spaces__shrinkSystemHeap(chunk, 0);
    }

    {
        if (!spaces__preInitThreads)
            (--(&spaces__mutexGlobal)->count, pthread_mutex_unlock(&(&spaces__mutexGlobal)->m));
    };

    return bResult;
};

void *_spaces__sysRealloc(void *mem, size_t size, unsigned flags)
{
    return _spaces__sysReallocChunk(0, mem, size, flags);
};

void *_spaces__sysReallocChunk(SpacesChunk chunk, void *mem, size_t size, unsigned flags)
{
    void *result;

    if (chunk) {
        if (chunk->flags & (0x0001u | 0x0010u)) {

            chunk = chunk->smpParent;

        } else
            chunk = 0;
    }

    if (_spaces__sysResizeChunk(chunk, mem, size, flags))
        return mem;
    else if ((result = _spaces__sysAllocChunk(chunk, size, flags)) != 0) {
        size_t oldSize = _spaces__sysSize(mem);

        memcpy(result, mem, (((size) < (oldSize)) ? (size) : (oldSize)));
        _spaces__sysFreeChunk(chunk, mem);
    }

    return result;
};

Bool _spaces__sysResize(void *mem, size_t size, unsigned flags)
{
    return _spaces__sysResizeChunk(0, mem, size, flags);
};

Bool _spaces__sysResizeChunk(SpacesChunk chunk, void *mem, size_t size, unsigned flags)
{
    size_t reqSize = size;
    Area *area = (Area *) mem - 1;
    size_t oldSize = area->commitSize;
    size_t oldSize64 = ((area)->sizeOrFree.inUseSize & ~1ul);
    Bool bResult = 0;
    size_t size64;

    if (chunk) {
        if (chunk->flags & (0x0001u | 0x0010u)) {

            chunk = chunk->smpParent;

            if (chunk == mem
                && !((unsigned long) ((unsigned long) (area) & ((unsigned long) ((0x10000) - 1u))) ==
                     (unsigned long) 0u)) {

                return 0;
            }
        } else
            chunk = 0;
    }

    if ((flags & 0x1000u)
        && size >
        (0x00010000lu -
         ((PageSize)
          ((PageSize) ((PageSize) (sizeof(Area)) + (PageSize) ((sizeof(double)) - 1u)) &
           ((PageSize) (~((PageSize) ((sizeof(double)) - 1u))))))))
        size =
            (0x00010000lu -
             ((PageSize)
              ((PageSize) ((PageSize) (sizeof(Area)) + (PageSize) ((sizeof(double)) - 1u)) &
               ((PageSize) (~((PageSize) ((sizeof(double)) - 1u)))))));

    size +=
        ((PageSize)
         ((PageSize) ((PageSize) (sizeof(Area)) + (PageSize) ((sizeof(double)) - 1u)) &
          ((PageSize) (~((PageSize) ((sizeof(double)) - 1u))))));

    size =
        ((unsigned long) ((unsigned long) ((unsigned long) ((size)) + (unsigned long) ((0x00010000lu) - 1u)) &
                          ((unsigned long) (~((unsigned long) ((0x00010000lu) - 1u))))));
    size64 =
        ((unsigned long) ((unsigned long) ((unsigned long) ((size)) + (unsigned long) ((0x10000) - 1u)) &
                          ((unsigned long) (~((unsigned long) ((0x10000) - 1u))))));

    {
        if (!spaces__createAndEnterMutex(&spaces__mutexGlobal))
            return 0;
    };

    if (area->prevFreeSize == 0x0010u) {

        bResult = spaces__sysResizeM(chunk, area, oldSize, &size, oldSize64, &size64, flags | 0x2000u);

        if (bResult) {
            ((area)->sizeOrFree.freeArea = 0, (area)->sizeOrFree.inUseSize = (size64) | 1ul);
            area->commitSize = size;

            size -=
                ((PageSize)
                 ((PageSize) ((PageSize) (sizeof(Area)) + (PageSize) ((sizeof(double)) - 1u)) &
                  ((PageSize) (~((PageSize) ((sizeof(double)) - 1u))))));

            if ((flags & 0x0100u) && size > reqSize)
                memset((char *) mem + reqSize, 0, size - reqSize);
        }
    } else if (size <= oldSize) {
        if (size64 < oldSize64) {

            Area *tail = area, *nextArea;

            ((area)->sizeOrFree.freeArea = 0, (area)->sizeOrFree.inUseSize = (size64) | 1ul);

            nextArea = ((Area *) ((char *) (area) + (size64)));

            if (tail->tailArea) {
                {
                    (nextArea)->tailArea = (tail)->tailArea;
                    (tail)->tailArea = 0;
                    (nextArea)->tailArea->area = (nextArea);
                };
            } else
                nextArea->tailArea = 0;
            ((nextArea)->sizeOrFree.freeArea = 0, (nextArea)->sizeOrFree.inUseSize = (oldSize64 - size64) | 1ul);

            nextArea->prevFreeSize = 0;
            nextArea->commitSize = oldSize - size64;

            _spaces__sysFreeChunk(chunk, nextArea + 1);

            area->commitSize = oldSize = size64;
        }

        if (size < oldSize) {

            if (!spaces__pageOutArea(chunk, area, size, 0))
                size = area->commitSize;
        }

        size -=
            ((PageSize)
             ((PageSize) ((PageSize) (sizeof(Area)) + (PageSize) ((sizeof(double)) - 1u)) &
              ((PageSize) (~((PageSize) ((sizeof(double)) - 1u))))));

        if ((flags & 0x0100u) && size > reqSize)
            memset((char *) mem + reqSize, 0, size - reqSize);

        bResult = 1;
    } else {

        if (oldSize < oldSize64) {

            spaces__pageInArea(area, area->commitSize, (((size) < (oldSize64)) ? (size) : (oldSize64)), 0);
            if (flags & 0x0100u)
                memset((char *) area + oldSize, 0, area->commitSize - oldSize);
        }

        if (area->commitSize >= size) {
            bResult = 1;
        } else if (area->commitSize == oldSize64) {
            FreeArea *freeArea;
            Area *oldArea = area;

            area = ((area)->tailArea ? 0 : ((Area *) ((char *) (area) + (oldSize64))));

            if (area)
                freeArea = (((area)->sizeOrFree.inUseSize & 1ul) ? 0 : (area)->sizeOrFree.freeArea);
            else {

                if (spaces__coelesceTailAreas)
                    freeArea = spaces__growSystemHeap(chunk,
                                                      ((Area *) ((char *) (oldArea) + (oldSize64))),
                                                      oldArea->tailArea, size64 - oldSize64, 0);
                else
                    freeArea = 0;
            }

            if (freeArea
                && freeArea->size >= size64 - oldSize64
                && (area = spaces__sysAllocChunk1(chunk, &freeArea,
                                                  size - oldSize64 -
                                                  ((PageSize)
                                                   ((PageSize)
                                                    ((PageSize) (sizeof(Area)) +
                                                     (PageSize) ((sizeof(double)) -
                                                                 1u)) &
                                                    ((PageSize) (~((PageSize) ((sizeof(double)) - 1u)))))), flags, 1))
                != 0) {

                area--;
                oldArea->sizeOrFree.inUseSize += ((area)->sizeOrFree.inUseSize & ~1ul);
                oldArea->commitSize += area->commitSize;

                if (area->tailArea) {
                    {
                        (oldArea)->tailArea = (area)->tailArea;
                        (area)->tailArea = 0;
                        (oldArea)->tailArea->area = (oldArea);
                    };
                }

                if (flags & 0x0100u)
                    memset(area, 0,
                           ((PageSize)
                            ((PageSize) ((PageSize) (sizeof(Area)) + (PageSize) ((sizeof(double)) - 1u)) &
                             ((PageSize) (~((PageSize) ((sizeof(double)) - 1u)))))));

                area = oldArea;

                bResult = 1;
            } else if (oldSize < oldArea->commitSize) {

                spaces__pageOutArea(chunk, oldArea, oldSize, 0);
            }
        }
    }

    {
        if (!spaces__preInitThreads)
            (--(&spaces__mutexGlobal)->count, pthread_mutex_unlock(&(&spaces__mutexGlobal)->m));
    };

    return bResult;
};

size_t _spaces__sysSize(void *mem)
{

    return ((Area *) mem - 1)->commitSize -
        ((PageSize)
         ((PageSize) ((PageSize) (sizeof(Area)) + (PageSize) ((sizeof(double)) - 1u)) &
          ((PageSize) (~((PageSize) ((sizeof(double)) - 1u))))));
};

static FreeArea *spaces__allocFreeArea(Chunk * chunk, Area * area, size_t size)
{

    if (chunk)
        return spaces__allocFreeArea1(chunk, area, size, &chunk->freeAreas, &chunk->freeFreeAreas);
    else
        return spaces__allocFreeArea1(chunk, area, size, &spaces__freeAreas, &spaces__freeFreeAreas);
};

static TailArea *spaces__allocTailArea(Chunk * chunk, Area * area, size_t size)
{

    if (chunk)
        return spaces__allocFreeArea1(chunk, area, size, &chunk->tailAreas, &chunk->freeFreeAreas);
    else
        return spaces__allocFreeArea1(chunk, area, size, &spaces__tailAreas, &spaces__freeFreeAreas);
};

static FreeArea *spaces__allocFreeArea1(Chunk * chunk, Area * area, size_t size, FreeArea ** head, FreeArea ** freelist)
{

    if (chunk) {

    }

    {
        FreeArea *freeArea = *freelist;

        if (freeArea) {
            if (head)
                *freelist = (*freelist)->next;
        } else {

            FreeArea *newArea, *lastArea, *freeList;
            FreeAreaAlloc *alloc;
            size_t size = 0x00010000lu;

            alloc = spaces__sysGetM(chunk, 0, size, &size, 0);
            if (!alloc) {
                _spaces__invokeErrorHandler1(0, SPACES_ERR_OUT_OF_MEMORY);
                return 0;
            }

            spaces__sysHeapTotal += size;

            alloc->size = size;
            alloc->next = spaces__freeAreaAllocs;
            spaces__freeAreaAllocs = alloc;

            freeArea =
                (FreeArea
                 *) ((unsigned
                      long) ((unsigned long) ((unsigned long) (alloc + 1) +
                                              (unsigned long) ((sizeof(FreeArea)) -
                                                               1u)) & ((unsigned
                                                                        long) (~((unsigned long) ((sizeof(FreeArea)) -
                                                                                                  1u))))));
            size = (((size_t) (size - sizeof(FreeAreaAlloc))) & ((size_t) (~((size_t) ((sizeof(FreeArea)) - 1u)))));
            newArea = freeArea;
            lastArea = (FreeArea *) ((char *) newArea + size) - 1;
            if (head)
                newArea++;
            freeList = 0;

            do {
                newArea->next = freeList;
                freeList = newArea;
            }
            while (newArea++ < lastArea);

            *freelist = freeList;
        }

        if (head) {
            FreeArea *tail = (*head)->prev;

            freeArea->size = size;
            freeArea->area = area;

            while ((char *) tail->area > (char *) area)
                tail = tail->prev;

            {
                (freeArea)->prev = (tail);
                (freeArea)->next = (tail)->next;
                (tail)->next->prev = (freeArea);
                (tail)->next = (freeArea);
            };
        }

        return freeArea;
    }
};

static void spaces__freeFreeArea(Chunk * chunk, FreeArea * freeArea)
{

    if (chunk)
        spaces__freeFreeArea1(chunk, freeArea, &chunk->freeAreas, &chunk->freeFreeAreas);
    else
        spaces__freeFreeArea1(chunk, freeArea, &spaces__freeAreas, &spaces__freeFreeAreas);
};

__attribute__((unused))
static void spaces__freeTailArea(Chunk * chunk, TailArea * tailArea)
{

    if (chunk)
        spaces__freeFreeArea1(chunk, tailArea, &chunk->tailAreas, &chunk->freeFreeAreas);
    else
        spaces__freeFreeArea1(chunk, tailArea, &spaces__tailAreas, &spaces__freeFreeAreas);
};

static void spaces__freeFreeArea1(Chunk * chunk, FreeArea * freeArea, FreeArea ** head, FreeArea ** freelist)
{

    if (chunk) {

    }

    {

        if (*head == freeArea) {

        }

        {
            (freeArea)->prev->next = (freeArea)->next;
            (freeArea)->next->prev = (freeArea)->prev;
        };
        freeArea->next = *freelist;
        *freelist = freeArea;
    }
};

static size_t spaces__sumFreeAreas()
{
    FreeAreaAlloc *alloc = spaces__freeAreaAllocs;
    size_t total = 0;

    while (alloc) {
        total += alloc->size;

        alloc = alloc->next;
    }

    return total;
};

static void spaces__flushFreeAreas()
{
    FreeAreaAlloc *alloc = spaces__freeAreaAllocs, *next;

    while (alloc) {
        size_t size = alloc->size;

        next = alloc->next;
        spaces__sysDecommitM(alloc, size);
        spaces__sysFreeAddressSpace(alloc, size, 1, 0);
        alloc = next;
    }

    spaces__freeAreaAllocs = 0;
    spaces__freeFreeAreas = 0;
};

void spaces__initializeAreaChunk(AreaChunk * areaChunk, size_t totalSize, size_t size)
{
    Chunk *chunk = &areaChunk->chunk;

    ((&areaChunk->area)->sizeOrFree.freeArea = 0, (&areaChunk->area)->sizeOrFree.inUseSize = (size) | 1ul);
    areaChunk->area.tailArea = 0;
    areaChunk->area.commitSize = size;
    areaChunk->area.prevFreeSize = 0;

    size -= sizeof(Area);
    totalSize -= sizeof(Area);

    chunk->areaChunk = areaChunk;

    chunk->totalSize = totalSize;
    chunk->committedSize = size;

    chunk->freeFreeAreas = 0;

    chunk->freeAreas = &chunk->freeAreaSentinel;
    chunk->freeAreaSentinel.size = 0;
    chunk->freeAreaSentinel.area = 0;
    chunk->freeAreaSentinel.prev = &chunk->freeAreaSentinel;
    chunk->freeAreaSentinel.next = &chunk->freeAreaSentinel;

    chunk->tailAreas = &chunk->tailAreaSentinel;
    chunk->tailAreas->size = 0;
    chunk->tailAreas->area = 0;
    chunk->tailAreas->next = chunk->tailAreas;
    chunk->tailAreas->prev = chunk->tailAreas;
};

static FreeArea *spaces__growSystemHeap(Chunk * chunk, void *addr, TailArea * tailArea, size_t size, unsigned flags)
{
    void *allocAddr;
    Area *result;
    TailArea **tailHead;
    size_t allocSize;
    FreeArea **freelist;

    size =
        ((unsigned long) ((unsigned long) ((unsigned long) ((size)) + (unsigned long) ((0x10000) - 1u)) &
                          ((unsigned long) (~((unsigned long) ((0x10000) - 1u))))));

    if (chunk) {

        tailHead = &chunk->tailAreas;
        freelist = &chunk->freeFreeAreas;
    } else {
        if (!(flags & 0x0080u)
            && spaces__sysHeapTotal + size > spaces__processHeapLimit) {
            if (!_spaces__invokeErrorHandler1(0, SPACES_ERR_EXCEEDED_HEAP_LIMIT))
                return 0;
        }

        tailHead = &spaces__tailAreas;
        freelist = &spaces__freeFreeAreas;
    }

    if (!addr) {

        if (!spaces__allocFreeArea1(chunk, 0, size, 0, freelist))
            return 0;
    }

    if (spaces__coelesceTailAreas) {
        if (!tailArea)
            tailArea = (*tailHead)->next;

        if (tailArea == *tailHead)
            tailArea = 0;
    } else {
    }

    do {
        size_t minSize = (flags & (0x1000u | 0x00100000u)) ? 0x00010000lu : size;

        if (addr)
            allocAddr = addr;
        else if (tailArea)
            allocAddr =
                ((Area *) ((char *) (tailArea->area) +
                           ((((tailArea->area)->sizeOrFree.inUseSize & 1ul) ? ((tailArea->area)->sizeOrFree.
                                                                               inUseSize & ~1ul) : (tailArea->area)->
                             sizeOrFree.freeArea->size))));
        else
            allocAddr = 0;

        if (addr)
            allocSize = size;
        else
            allocSize = (((size) > (spaces__processGrowIncrement)) ? (size) : (spaces__processGrowIncrement));

        result = (Area *) spaces__sysGetM(chunk, allocAddr, minSize, &allocSize, flags);

        if (!result) {
            if (addr)
                break;
            else if (tailArea) {
                tailArea = tailArea->next;

                if (tailArea == *tailHead)
                    tailArea = 0;
            }
        }
    } while (!result && allocAddr);

    if (result) {
        FreeArea *freeArea;

        size_t alignDiff =
            ((unsigned long) ((unsigned long) ((unsigned long) ((result)) + (unsigned long) ((0x10000) - 1u)) &
                              ((unsigned long) (~((unsigned long) ((0x10000) - 1u)))))) - (size_t) result;

        result =
            (Area
             *) ((unsigned long) ((unsigned long) ((unsigned long) ((result)) + (unsigned long) ((0x10000) - 1u)) &
                                  ((unsigned long) (~((unsigned long) ((0x10000) - 1u))))));
        size = (((unsigned long) ((allocSize - alignDiff))) & ((unsigned long) (~((unsigned long) ((0x10000) - 1u)))));

        if (tailArea) {

            if (!((tailArea->area)->sizeOrFree.inUseSize & 1ul)) {

                Area *result1 = tailArea->area;

                freeArea = (((result1)->sizeOrFree.inUseSize & 1ul) ? 0 : (result1)->sizeOrFree.freeArea);
                if (result1->commitSize < freeArea->size) {
                    if (!spaces__pageInArea(result1, result1->commitSize, freeArea->size, 1))
                        result1 = 0;
                }

                if (result1 == tailArea->area) {
                    result = result1;
                    freeArea->size += size;
                    result->commitSize += size;
                }
            }
            if (result != tailArea->area) {

                freeArea = spaces__allocFreeArea(chunk, result, size);
                ((result)->sizeOrFree.inUseSize = 0, (result)->sizeOrFree.freeArea = freeArea);
                result->prevFreeSize = 0;
                result->commitSize = freeArea->size;
                {
                    (result)->tailArea = (tailArea->area)->tailArea;
                    (tailArea->area)->tailArea = 0;
                    (result)->tailArea->area = (result);
                };
            }

            tailArea->size += size;
        } else {

            freeArea = spaces__allocFreeArea(chunk, result, size);
            ((result)->sizeOrFree.inUseSize = 0, (result)->sizeOrFree.freeArea = freeArea);
            result->tailArea = spaces__allocTailArea(chunk, result, size);
            result->commitSize = freeArea->size;
            result->prevFreeSize = 0;
        }

        spaces__sysTotalFree += size;
        spaces__sysHeapTotal += size;

        return (((result)->sizeOrFree.inUseSize & 1ul) ? 0 : (result)->sizeOrFree.freeArea);
    }

    return 0;
};

static void spaces__shrinkSystemHeap(Chunk * chunk, Bool bFlush)
{
    FreeArea *head = (chunk ? chunk->freeAreas : spaces__freeAreas), *freeArea = head, *nextArea;
    if (!chunk) {
        TailArea *tailArea = spaces__tailAreas->prev, *nextTail;

        do {
            nextTail = tailArea->prev;

            if (tailArea->area && !((tailArea->area)->sizeOrFree.inUseSize & 1ul))
                spaces__pageOutArea(chunk, tailArea->area, 0x00010000lu, 1);
        }
        while ((tailArea = nextTail) != spaces__tailAreas
               && (bFlush || spaces__sysTotalFree > spaces__processFreeBytes));
    }

    do {

        nextArea = freeArea->prev;

        if (freeArea->area && freeArea->area->commitSize > 0x00010000lu)
            spaces__pageOutArea(chunk, freeArea->area, 0x00010000lu, 1);
    }
    while ((bFlush || spaces__sysTotalFree > spaces__processFreeBytes)
           && (freeArea = nextArea) != head);
};

static Bool spaces__pageOutArea(Chunk * chunk, Area * area, size_t size, Bool bAdjustTotalFree)
{

    if (size ==
        (((area)->sizeOrFree.inUseSize & 1ul) ? ((area)->sizeOrFree.inUseSize & ~1ul) : (area)->sizeOrFree.freeArea->
         size))
        return 0;
    if (chunk)
        return 0;

    if (area->commitSize > 0x00010000lu && !spaces__sysDecommitM((char *) area + size, area->commitSize - size)) {
        return 0;
    }

    if (bAdjustTotalFree)
        spaces__sysTotalFree -= area->commitSize - size;

    spaces__sysHeapTotal -= area->commitSize - size;

    area->commitSize = size;

    if (area->tailArea && !((area)->sizeOrFree.inUseSize & 1ul))
        spaces__shrinkAddressSpace(chunk, (((area)->sizeOrFree.inUseSize & 1ul) ? 0 : (area)->sizeOrFree.freeArea));

    return 1;
};

static Bool spaces__pageInArea(Area * area, size_t commitSize, size_t size, Bool bAdjustTotalFree)
{
    void *commitAddr = (char *) area + commitSize;

    if ((commitAddr = spaces__sysCommitM(commitAddr, size - commitSize))
        != 0) {

        if (bAdjustTotalFree)
            spaces__sysTotalFree += size - commitSize;

        spaces__sysHeapTotal += size - commitSize;

        area->commitSize = size;

        return 1;
    } else
        return 0;
};

static void spaces__shrinkAddressSpace(Chunk * chunk, FreeArea * freeArea)
{
    size_t released = 0;
    if (chunk)
        return;

    if (freeArea->size > 0x00010000lu)
        spaces__sysFreeAddressSpace((char *) freeArea->area + 0x00010000lu,
                                    freeArea->size - 0x00010000lu, 1, &released);

    if (released == freeArea->size) {
        spaces__freeFreeArea(chunk, freeArea);
    } else {
        freeArea->size -= released;
        freeArea->area->tailArea->size -= released;
    }
};

Bool spaces__sysResizeM(Chunk * chunk, void *addr, size_t oldSize,
                        size_t *size, size_t oldSize64, size_t *size64, unsigned flags)
{

    if (*size <= oldSize) {
        if (*size < oldSize) {
            size_t shrinkSize64 = oldSize64 - *size64, freeSize64 = shrinkSize64;

            if (*size < *size64) {
                size_t decommitSize = (((*size64) < (oldSize)) ? (*size64) : (oldSize)) - *size;

                spaces__sysDecommitM((char *) addr + *size, decommitSize);
            }

            if (freeSize64) {

                if (!spaces__sysReturnM(chunk, (void *) ((char *) addr + *size64), &freeSize64, flags, 1)) {
                    return 0;
                }

                if (freeSize64 != shrinkSize64)
                    *size64 += (shrinkSize64 - freeSize64);
            }

            spaces__sysHeapTotal -= oldSize - *size;
        }

        return 1;
    } else {
        size_t size1 = *size - oldSize;

        if (!(flags & 0x0080u)
            && spaces__sysHeapTotal + size1 > spaces__processHeapLimit) {
            if (!_spaces__invokeErrorHandler1(0, SPACES_ERR_EXCEEDED_HEAP_LIMIT))
                return 0;
        }

        if (oldSize != oldSize64) {
            size_t commitSize = (((size1) < (oldSize64 - oldSize)) ? (size1) : (oldSize64 - oldSize));

            if (commitSize)
                if (!spaces__sysCommitM((char *) addr + oldSize, commitSize))
                    return 0;

            spaces__sysHeapTotal += commitSize;

            if (size1 == commitSize) {
                *size = oldSize + size1;
                *size64 = oldSize64;
                return 1;
            } else
                size1 -= commitSize;
        }

        size1 =
            ((unsigned long) ((unsigned long) ((unsigned long) ((size1)) + (unsigned long) ((0x10000) - 1u)) &
                              ((unsigned long) (~((unsigned long) ((0x10000) - 1u))))));
        if (spaces__sysGetM(chunk, (char *) addr + oldSize64, size1, &size1, flags)) {
            *size64 = *size = oldSize64 + size1;

            spaces__sysHeapTotal += size1;

            return 1;
        }
    }

    return 0;
};

static void spaces__flushAreas()
{
    FreeArea *freeArea;

    spaces__freeAreas = &spaces__freeAreaSentinel;

    while ((freeArea = spaces__freeAreas->next) != spaces__freeAreas) {

        spaces__sysDecommitM(freeArea->area, freeArea->area->commitSize);
        spaces__sysFreeAddressSpace(freeArea->area, freeArea->size, 1, 0);
        {
            (freeArea)->prev->next = (freeArea)->next;
            (freeArea)->next->prev = (freeArea)->prev;
        };
    }

    spaces__tailAreas = &spaces__tailAreaSentinel;
    spaces__tailAreas->next = spaces__tailAreas->prev = spaces__tailAreas;
};

SpacesChunk spaces__sysAllocArea(size_t size, size_t totalSize, unsigned flags, void *addr, void *security)
{
    AreaChunk *areaChunk = 0;
    size_t argTotalSize;

    if (flags & 0x4000u)
        return (Chunk *) _spaces__sysAllocChunk(addr, size, flags);

    if ((flags & 0x1000u)
        && size >
        (0x00010000lu -
         ((PageSize)
          ((PageSize) ((PageSize) (sizeof(Area)) + (PageSize) ((sizeof(double)) - 1u)) &
           ((PageSize) (~((PageSize) ((sizeof(double)) - 1u))))))))
        size =
            (0x00010000lu -
             ((PageSize)
              ((PageSize) ((PageSize) (sizeof(Area)) + (PageSize) ((sizeof(double)) - 1u)) &
               ((PageSize) (~((PageSize) ((sizeof(double)) - 1u)))))));

    size +=
        ((PageSize)
         ((PageSize) ((PageSize) (sizeof(Area)) + (PageSize) ((sizeof(double)) - 1u)) &
          ((PageSize) (~((PageSize) ((sizeof(double)) - 1u))))));

    if (!((unsigned long) ((unsigned long) (addr) & ((unsigned long) ((0x00010000lu) - 1u))) == (unsigned long) 0u)) {

        if (totalSize < 0x00010000lu)
            return 0;

        totalSize -= 0x00010000lu - ((unsigned long) addr & (0x00010000lu - 1));
        addr =
            (void
             *) ((unsigned long) ((unsigned long) ((unsigned long) ((addr)) + (unsigned long) ((0x00010000lu) - 1u)) &
                                  ((unsigned long) (~((unsigned long) ((0x00010000lu) - 1u))))));
    }

    if (((unsigned long) ((unsigned long) (addr) & ((unsigned long) ((0x10000) - 1u))) == (unsigned long) 0u)
        || size > 0x10000 - ((unsigned long) addr & 0xFFFF)) {

        size =
            ((unsigned long) ((unsigned long) ((unsigned long) ((size)) + (unsigned long) ((0x10000) - 1u)) &
                              ((unsigned long) (~((unsigned long) ((0x10000) - 1u))))));
    } else
        size = 0x10000 - ((unsigned long) addr & 0xFFFF);

    if (totalSize < size + 0x10000)
        return 0;

    argTotalSize = totalSize =
        (((unsigned long) ((totalSize - size))) & ((unsigned long) (~((unsigned long) ((0x10000) - 1u)))));
    totalSize += size;

    if (totalSize < argTotalSize)
        return 0;

    if (flags & 0x0020u)
        areaChunk = (AreaChunk *) addr;
    else {
        {
            if (!spaces__createAndEnterMutex(&spaces__mutexGlobal))
                return 0;
        };

        areaChunk = (AreaChunk *) spaces__sysGetM((SpacesChunk) addr, addr, size, &size, 0);

        {
            if (!spaces__preInitThreads)
                (--(&spaces__mutexGlobal)->count, pthread_mutex_unlock(&(&spaces__mutexGlobal)->m));
        };

        if (!areaChunk)
            return 0;
    }

    if (flags & 0x0100u)
        memset(areaChunk, 0, size);

    spaces__initializeAreaChunk(areaChunk, totalSize, size);

    if (flags & 0x0001u) {
        if (!spaces__initSharedChunk(&areaChunk->chunk, flags, security))
            return 0;
    }

    return &areaChunk->chunk;
};

SpacesChunk spaces__getThreadChunk(void);
int spaces__freeThreadChunks(void);
SpacesChunk spaces__getThreadChunk()
{
    return spaces_init_default_chunk();
};

int spaces__freeThreadChunks()
{
    return 1;
};

Bool spaces__smpEnqueueFree(ThreadChunk p, void *ptr)
{
    volatile SmpQueue *block = (volatile SmpQueue *) ptr, *next;

    if (((((p)->lock) && spaces__test_and_clear(&(p)->lock)))
        || (p->locktid && p->locktid == pthread_self())
        ) {
        return 0;
    }

    do {
        next = p->smpFreeQueue;
        block->next = next;
    } while (spaces__InterlockedCompareExchange((void *volatile *) &p->smpFreeQueue, (void *) block, (void *) next)
             != next);


    return 1;
};

void spaces__smpFlushQueue(ThreadChunk p)
{

    SmpQueue volatile *next;
    SmpQueue volatile *freelist;


    freelist = (SmpQueue volatile *)
        spaces__InterlockedExchange((long *) &p->smpFreeQueue, (long) 0);


    p->locktid = pthread_self();

    while (freelist) {

        next = freelist->next;
        spaces_chunk_free((void *) freelist);
        freelist = next;
    }

    p->locktid = 0;

};

static int spaces__smpPrimes[] __attribute__((unused)) = { 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67, 71,
    73, 79, 83, 89, 97, 101, 103, 107, 109, 113, 127, 131, 137, 139, 149, 151,
    157, 163, 167, 173, 179, 181, 191, 193, 197, 199, 211, 223, 227, 229, 233,
    239, 241, 251, 257
};

static int spaces__nextPrime[] = { 1, 2, 3, 5, 5, 7, 7, 11, 11, 11, 11, 13, 13, 17, 17, 17, 17, 19, 19,
    23, 23, 23, 23, 29, 29, 29, 29, 29, 29, 31, 31, 37, 37, 37, 37, 37, 37,
    41, 41, 41, 41, 43, 43, 47, 47, 47, 47, 53, 53, 53, 53, 53, 53, 59, 59,
    59, 59, 59, 59, 61, 61, 67, 67, 67, 67, 67, 67, 71, 71, 71, 71, 73, 73,
    79, 79, 79, 79, 79, 79, 83, 83, 83, 83, 89, 89, 89, 89, 89, 89, 97, 97,
    97, 97, 97, 97, 97, 97, 101, 101, 101, 101, 107, 107, 107, 107, 107, 107,
    109, 109, 113, 113, 113, 113, 127, 127, 127, 127, 127, 127, 127, 127, 127,
    127, 127, 127, 127, 127, 131, 131, 131, 131, 137, 137, 137, 137, 137, 137,
    139, 139, 149, 149, 149, 149, 149, 149, 149, 149, 149, 149, 151, 151, 157,
    157, 157, 157, 157, 157, 163, 163, 163, 163, 163, 163, 167, 167, 167, 167,
    173, 173, 173, 173, 173, 173, 179, 179, 179, 179, 179, 179, 181, 181, 191,
    191, 191, 191, 191, 191, 191, 191, 191, 191, 193, 193, 197, 197, 197, 197,
    199, 199, 211, 211, 211, 211, 211, 211, 211, 211, 211, 211, 211, 211, 223,
    223, 223, 223, 223, 223, 223, 223, 223, 223, 223, 223, 227, 227, 227, 227,
    229, 229, 233, 233, 233, 233, 239, 239, 239, 239, 239, 239, 241, 241, 251,
    251, 251, 251, 251, 251, 251, 251, 251, 257, 257, 257, 257, 257, 257, 257, 257
};

static Bool spaces__initPageCache(void);

ThreadChunk spaces__getProcessorChunk(ThreadChunk parent)
{
    ThreadChunk *pChunk;
    ThreadChunk chunk = 0, firstChunk;
    static int totalChunkSharing = 0;

    if (parent->flags & 0x8000u) {
        {
            ThreadID tid_ = pthread_self();
            ThreadLocalChunk *tlp_ = &spaces__threadLocalChunks[tid_ % 997];
            if (tlp_->tid == tid_)
                (chunk) = tlp_->chunk;
        };
        if (chunk) {
            if (chunk->flags & 0x00010000u) {

                return chunk;
            } else if (((((chunk)->lock) && spaces__test_and_clear(&(chunk)->lock))))
                return chunk;
        }
    }
    parent = parent->smpParent;
    for (;;) {
        pChunk = &parent->subChunks[pthread_self() % 257];

        if ((chunk = *pChunk) != 0) {
            if (((((chunk)->lock) && spaces__test_and_clear(&(chunk)->lock)))) {
                return chunk;
            }
        } else {
          addSubChunk:

            {
                if (!(pthread_mutex_lock(&(&spaces__mutexSMP)->m) == 0 && ++(&spaces__mutexSMP)->count))
                    return 0;
            };

            if (!*pChunk) {
                if (parent->subChunkCount >= parent->maxSubChunks) {
                    firstChunk = chunk = parent;

                    do {

                        if (chunk->subChunkSharing < firstChunk->subChunkSharing && !(chunk->flags & 0x00010000u))
                            firstChunk = chunk;
                    }
                    while ((chunk = chunk->smpNextChunk) != parent);

                    firstChunk->subChunkSharing++;
                    totalChunkSharing++;
                    *pChunk = firstChunk;
                } else if (spaces__mutexSMP.count > 1) {

                } else if (parent->flags & 0x0001u) {

                    (--(&spaces__mutexSMP)->count, pthread_mutex_unlock(&(&spaces__mutexSMP)->m));

                    if (((parent)->flags & 0x0002u)) { {
                            int i___ = 2;
                            int k___ = 0;
                            while (!((((parent)->lock) && spaces__test_and_clear(&(parent)->lock)))) {;
                                if (i___-- == 0) {
                                    spaces__smpYield(k___++);
                                    i___ = 2;
                                }
                            }
                    }
                    };
                    return parent;
                } else if ((chunk = spaces__initSubChunk(parent, 0)) != 0)
                    spaces__insertSubChunk(chunk, parent, pChunk);
            }

            if ((chunk = *pChunk) != 0) {

                if (chunk->flags & 0x8000u) {
                    Chunk *p = 0;
                    {
                        ThreadID tid_ = pthread_self();
                        ThreadLocalChunk *tlp_ = &spaces__threadLocalChunks[tid_ % 997];
                        if (tlp_->tid == tid_)
                            (p) = tlp_->chunk;
                    };

                    if (!p)
                        spaces__setThreadLocalChunk(chunk, 0);
                }
            }

            (--(&spaces__mutexSMP)->count, pthread_mutex_unlock(&(&spaces__mutexSMP)->m));

            if (chunk && ((((chunk)->lock) && spaces__test_and_clear(&(chunk)->lock))))
                return chunk;
        }

        chunk = *pChunk;
        chunk = firstChunk = chunk ? chunk->smpNextChunk : parent;

        do {
            if (!(chunk->flags & 0x00010000u)
                && ((((chunk)->lock) && spaces__test_and_clear(&(chunk)->lock)))) {
                return chunk;
            }

            chunk = chunk->smpNextChunk;
        }
        while (chunk != firstChunk);

        if (parent->subChunkCount < parent->maxSubChunks) {
            {
                if (!(pthread_mutex_lock(&(&spaces__mutexSMP)->m) == 0 && ++(&spaces__mutexSMP)->count))
                    return 0;
            };

            if (parent->subChunkCount < parent->maxSubChunks) {
                if (*pChunk && (*pChunk)->subChunkSharing && (*pChunk)->subChunkPosition != pChunk) {
                    (*pChunk)->subChunkSharing--;
                    totalChunkSharing--;
                    *pChunk = 0;
                } else {
                    if (!totalChunkSharing && *pChunk) {
                    }
                    {
                        int i = 257;
                        pChunk = &parent->subChunks[0] - 1;

                        if (totalChunkSharing) {
                            while (i--)
                                if (*++pChunk && (*pChunk)->subChunkSharing && (*pChunk)->subChunkPosition != pChunk) {
                                    (*pChunk)->subChunkSharing--;
                                    totalChunkSharing--;
                                    *pChunk = 0;
                                    break;
                                }
                        } else {

                            while (i--)
                                if (!*++pChunk)
                                    break;
                        }
                    }
                }
            }

            (--(&spaces__mutexSMP)->count, pthread_mutex_unlock(&(&spaces__mutexSMP)->m));

            if (!*pChunk)
                goto addSubChunk;
        }

        if (*pChunk && parent->maxSubChunks < parent->subChunkLimit && parent->subChunkCount >= parent->maxSubChunks) {
            {
                if (!(pthread_mutex_lock(&(&spaces__mutexSMP)->m) == 0 && ++(&spaces__mutexSMP)->count))
                    return 0;
            };

            if (parent->subChunkCount >= parent->maxSubChunks) {
                parent->maxSubChunks = spaces__nextPrime[parent->maxSubChunks];
                if ((*pChunk)->subChunkSharing && (*pChunk)->subChunkPosition != pChunk) {
                    (*pChunk)->subChunkSharing--;
                    totalChunkSharing--;
                    *pChunk = 0;
                }
            }

            (--(&spaces__mutexSMP)->count, pthread_mutex_unlock(&(&spaces__mutexSMP)->m));

            continue;
        }

        spaces__smpYield(0);
    }

};

void spaces__insertSubChunk(Chunk * chunk, Chunk * parent, ThreadChunk * pChunk)
{
    {
        if (!(pthread_mutex_lock(&(&spaces__mutexSMP)->m) == 0 && ++(&spaces__mutexSMP)->count))
            return;
    };

    parent->subChunkCount++;

    chunk->smpParent = parent;

    chunk->smpNextChunk = parent->smpNextChunk;
    parent->smpNextChunk = chunk;

    if (!pChunk || pChunk == &parent->subChunks[pthread_self() % 257]) {
        chunk->smpThreadID = pthread_self();
        chunk->subChunkPosition = pChunk;

        if (!pChunk) {

            pChunk = &parent->subChunks[pthread_self() % 257];
        }

        if (chunk->flags & 0x8000u)
            spaces__setThreadLocalChunk(chunk, 0);
    }

    *pChunk = chunk;

    (--(&spaces__mutexSMP)->count, pthread_mutex_unlock(&(&spaces__mutexSMP)->m));
};

Bool spaces__smpInitChunk(SpacesChunk chunk)
{
    static Bool bLimitSubchunks = 0;

    static Bool bFirst = 1;

    if (bFirst) {
        if (spaces__initThreadLocalChunk())
            bFirst = 0;
    }

    chunk->smpFreeQueue = 0;
    ((chunk)->lock = 1);
    ((chunk)->locktid = 0);
    chunk->smpThreadID = 0;

    {
        extern Bool spaces__preInitThreads;

        if (spaces__preInitThreads || !(chunk->flags & 0x0002u)
            || (chunk->flags & (0x00010000u | 0x00020000u))) {
            chunk->smpNextChunk = chunk->smpParent = chunk;

            if (chunk->flags & (0x00010000u | 0x00020000u)) {
                chunk->smpThreadID = pthread_self();
            }

            return 0;
        }
    }

    if (!(chunk->flags & 0x4000u)) {

        static int cpus;
        static int bFirst = 1;
        SpacesChunk *pChunk;

        if (bFirst) {

            bFirst = 0;

            cpus = spaces__getProcessorCount();

            if (!spaces__initMutex(&spaces__mutexSMP))
                return 0;

            if (!spaces__initPageCache())
                return 0;
        }

        if (!bLimitSubchunks) {

            chunk->maxSubChunks = spaces__nextPrime[(((257 - 1) < (cpus)) ? (257 - 1) : (cpus))];

            chunk->subChunkLimit = spaces__nextPrime[257 - 1];

        }

        chunk->subChunkSharing = 0;

        pChunk = &chunk->subChunks[pthread_self() % 257];
        *pChunk = chunk;
        chunk->smpThreadID = pthread_self();
        chunk->subChunkPosition = pChunk;
        chunk->smpNextChunk = chunk;
        chunk->smpParent = chunk;
        chunk->subChunkCount = 1;
    } else {
        chunk->smpNextChunk = 0;
        chunk->smpThreadID = 0;
        chunk->subChunkPosition = 0;
    }

    return 1;
};

Bool spaces_chunk_set_max_subchunks(SpacesChunk chunk, unsigned count)
{
    {
        if (!(chunk)) {
            (chunk) = (spaces_default_chunk = spaces_init_default_chunk());
        }
    };

    chunk = chunk->smpParent;

    chunk->subChunkLimit = spaces__nextPrime[(((257 - 1) < (count)) ? (257 - 1) : (count))];

    if (chunk->maxSubChunks > chunk->subChunkLimit)
        chunk->maxSubChunks = chunk->subChunkLimit;

    return 1;
};

static void spaces__pageCacheThread(void *arg);

static Bool spaces__bPageCacheThreadActive = 0;

static __attribute__((aligned(64)))
PageCache spaces__pageCache[4 + 1] = { 0 };

static Bool spaces__initPageCache()
{
    int i = 4;

    do {
        int cpus = spaces__getProcessorCount();

        {

            ((&spaces__pageCache[i])->lock = 1);

            if (i == 0) {
                spaces__pageCache[i].init = cpus * (32);
                spaces__pageCache[i].target = spaces__pageCache[i].init;
                spaces__pageCache[i].min = spaces__pageCache[i].target / 2;
                spaces__pageCache[i].max = spaces__pageCache[i].target * 2;
            } else
                spaces__pageCache[i].init = ((4 - i) * cpus);
        }
    }
    while (i--);

    if (!spaces__createEventPageCache())
        return 0;

    if (!spaces__runThread(spaces__pageCacheThread, 0, 0)) {
        spaces__deleteEventPageCache();
        return 0;
    }

    return 1;
};

Page *spaces__sysAllocPageCached(Chunk * chunk, size_t size, unsigned flags)
{
    unsigned i;
    PageCacheEntry *page = 0;
    PageCache *pageCache = 0;

    if (flags & 0x2000u)
        size +=
            ((PageSize)
             ((PageSize) ((PageSize) (sizeof(Area)) + (PageSize) ((sizeof(double)) - 1u)) &
              ((PageSize) (~((PageSize) ((sizeof(double)) - 1u))))));

    i = ((unsigned) (((size) - 1ul) >> 16ul));

    if (i < 4 && !(flags & (0x0001u | 0x0010u))) {
        int tries = 0;

        pageCache = &spaces__pageCache[i];

        do {

            if (((pageCache)->count) <= pageCache->min && !spaces__bPageCacheThreadActive)
                spaces__signalEventPageCache();

            if (((pageCache)->count) > 0) {
                {
                    int i___ = 2;
                    int k___ = 0;
                    while (!((((pageCache)->lock) && spaces__test_and_clear(&(pageCache)->lock)))) {;
                        if (i___-- == 0) {
                            spaces__smpYield(k___++);
                            i___ = 2;
                        }
                    }
                };

                page = pageCache->stack;

                if (page) {

                    pageCache->stack = page->next;
                    pageCache->count--;
                    pageCache->inUse++;
                }

                ((pageCache)->lock = 1);

            }

            if (!page && ((pageCache)->count) == 0) {
                if (pageCache->target == 0)
                    pageCache->min = pageCache->target = pageCache->init;

                spaces__smpYield(0);
            }

            if (tries++ == 4)
                break;
        }
        while (!page);
    }
    if (!page) {

        if (pageCache) {
            spaces__InterlockedIncrement((volatile long *)&pageCache->inUse);
        }

        page = _spaces__sysAllocChunk(chunk, size, flags);
    }

    return (Page *) page;
};

Bool spaces__sysFreePageCached(Page * page)
{
    int i = ((unsigned) (((_spaces__sysSize(page)) - 1ul) >> 16ul));
    PageCacheEntry *cachedPage = (PageCacheEntry *) page;
    Bool bResult = 1;
    PageCache *pageCache;

    if (page->chunk->flags & (0x0001u | 0x0010u)) {

        return _spaces__sysFreeChunk(page->chunk, page);
    }

    if (i > 4) {

        i = 4;
    }

    pageCache = &spaces__pageCache[i];
    {
        int i___ = 2;
        int k___ = 0;
        while (!((((pageCache)->lock) && spaces__test_and_clear(&(pageCache)->lock)))) {;
            if (i___-- == 0) {
                spaces__smpYield(k___++);
                i___ = 2;
            }
        }
    };

    cachedPage->next = pageCache->stack;
    pageCache->stack = cachedPage;
    pageCache->count++;
    pageCache->inUse--;

    ((pageCache)->lock = 1);

    if (((pageCache)->count) > pageCache->max && !spaces__bPageCacheThreadActive)
        spaces__signalEventPageCache();

    bResult = 1;

    return bResult;
};

Bool spaces__termPageCache()
{
    int i = 4;

    spaces__deleteEventPageCache();

    for (i = 0; i < 4; i++) {

        {
            spaces__pageCache[i].target = 0;
            spaces__pageCache[i].init = 0;
            spaces__pageCache[i].min = 0;
            spaces__pageCache[i].max = 0;
            spaces__pageCache[i].inUse = 0;
        }
    }
    while (i--);

    spaces__pageCacheThread(0);

    return 1;
};

static void spaces__pageCacheThread(void *arg)
{
    Bool bRepeat = 0;
    unsigned short counter = 0;

    (void) arg;

    do {
        do {
            unsigned i;
            PageCacheEntry *page;

            spaces__bPageCacheThreadActive = 1;

            bRepeat = 0;

            for (i = 0; i < 4; i++) {
                {
                    PageCache *pageCache = &spaces__pageCache[i];

                    if (counter == 0) {

                        const int maxDepth = (0x7fff * 2 + 1)
                            / 4;
                        int minDepth = pageCache->init;

                        if (i > 0 && pageCache->inUse <= 0)
                            minDepth = 0;

                        minDepth = (((minDepth) > (pageCache->inUse >> 4)) ? (minDepth) : (pageCache->inUse >> 4));

                        pageCache->target = (((maxDepth) < (minDepth)) ? (maxDepth) : (minDepth));

                        pageCache->min = pageCache->target >> 1;
                        pageCache->max = pageCache->target << 1;
                    }

                    while (((pageCache)->count) < pageCache->target) {
                        unsigned flags = (i == 0) ? 0 : 0x2000u;
                        page =
                            _spaces__sysAllocChunk(0,
                                                   (((unsigned
                                                      long) ((unsigned
                                                              long) ((unsigned long) ((((size_t) ((i) + 1) << 16ul))) +
                                                                     (unsigned long) ((0x10000) -
                                                                                      1u)) & ((unsigned
                                                                                               long) (~((unsigned
                                                                                                         long) ((0x10000) - 1u)))))) - ((PageSize) ((PageSize) ((PageSize) (sizeof(Area)) + (PageSize) ((sizeof(double)) - 1u)) & ((PageSize) (~((PageSize) ((sizeof(double)) - 1u))))))), flags);

                        if (page) {

                            {
                                int i___ = 2;
                                int k___ = 0;
                                while (!((((pageCache)->lock) && spaces__test_and_clear(&(pageCache)->lock)))) {
                                    continue;
                                    if (i___-- == 0) {
                                        spaces__smpYield(k___++);
                                        i___ = 2;
                                    }
                                }
                            };

                            page->next = pageCache->stack;
                            pageCache->stack = page;
                            pageCache->count++;

                            ((pageCache)->lock = 1);

                            bRepeat = 1;
                        }
                    }
                }

            }

            counter++;

            if (bRepeat)
                continue;

            for (i = 0; i <= 4; i++) {
                {
                    PageCache *pageCache = &spaces__pageCache[i];

                    while (((pageCache)->count) > pageCache->max) {

                        if (((&spaces__pageCache[0])->count) < spaces__pageCache[0].target) {
                            bRepeat = 1;
                            goto skipFreeLoop;
                        }

                        page = 0;

                        if (((pageCache)->count) > 0) {

                            if (((((pageCache)->lock) && spaces__test_and_clear(&(pageCache)->lock)))) {

                                page = pageCache->stack;

                                if (page) {
                                    pageCache->stack = page->next;
                                    pageCache->count--;
                                }

                                ((pageCache)->lock = 1);
                            } else
                                bRepeat = 1;
                        }

                        if (page) {
                            _spaces__sysFreeChunk(0, page);
                            bRepeat = 1;
                        }
                    }

                }
            }

          skipFreeLoop:
        } while (bRepeat || (spaces__bPageCacheThreadActive = 0, spaces__waitForEventPageCache()));
    }
    while (spaces__eventPageCache.__size);
};

void *spaces__mmap(void *addr, size_t size, unsigned flags);
Bool spaces__munmap(void *addr, size_t size);

size_t spaces__heapBottom = 0;
size_t spaces__heapTop = 0;

void *spaces__sysGetM(Chunk * chunk, void *addr, size_t minSize, size_t *size, unsigned flags)
{
    if (chunk) {
        if ((void *) chunk == addr)
            return addr;
        else {

            size_t availSize = chunk->totalSize - chunk->committedSize;
            void *result;

            minSize =
                ((unsigned long) ((unsigned long) ((unsigned long) ((minSize)) + (unsigned long) ((0x10000) - 1u)) &
                                  ((unsigned long) (~((unsigned long) ((0x10000) - 1u))))));

            if (availSize < minSize)
                return 0;

            *size =
                ((unsigned long) ((unsigned long) ((unsigned long) ((*size)) + (unsigned long) ((0x10000) - 1u)) &
                                  ((unsigned long) (~((unsigned long) ((0x10000) - 1u))))));

            if (availSize < *size)
                *size = availSize;

            result = (char *) chunk + chunk->committedSize;

            chunk->committedSize += *size;

            return result;
        }
    } else {

        if (*size <= (0x7fffffff >> 1)
            && (addr || !(flags & 0x2000u))) {

            size_t allocSize = *size, result, brkDiff;

            if (addr && spaces__sbrk(0) != addr)
                return 0;


            do {
              again:
                result = (size_t) spaces__sbrk(allocSize);

                if (result) {
                    if (addr && (void *) result != addr) {
                        result = 0;
                        break;
                    }

                    brkDiff =
                        ((unsigned
                          long) ((unsigned long) ((unsigned long) ((result)) +
                                                  (unsigned long) ((0x10000) -
                                                                   1u)) & ((unsigned
                                                                            long) (~((unsigned long) ((0x10000) -
                                                                                                      1u)))))) - result;

                    if (brkDiff) {

                        size_t result1 = (size_t) spaces__sbrk(brkDiff);

                        if (result1 && result1 == result + allocSize) {
                            allocSize += brkDiff;
                        } else if (allocSize - brkDiff < minSize) {

                            if (addr) {
                                result = 0;
                                break;
                            } else
                                goto again;
                        }
                    }
                }
            }
            while (!result && (allocSize >>= 1) >= minSize);


            if (result) {

                if (!spaces__heapBottom)
                    spaces__heapBottom = result;
                spaces__heapTop = result + allocSize;

                *size = allocSize;

                return (void *) result;
            }
        }

        if (addr)
            return 0;
        else {
            void *result;
            size_t allocSize = *size;

            if (allocSize < minSize + 0x00010000lu)
                allocSize += 0x00010000lu;

            do {

                result = spaces__mmap(0, allocSize, 0);

            }
            while (!result && (allocSize >>= 1) >= minSize + 0x00010000lu);

            if (result) {
                size_t alignDiff = (size_t)
                    (((unsigned long) ((unsigned long) ((unsigned long) ((result)) + (unsigned long) ((0x10000) - 1u)) &
                                       ((unsigned long) (~((unsigned long) ((0x10000) - 1u)))))) -
                     (unsigned long) result);

                if (alignDiff) {

                    spaces__munmap(result, alignDiff);
                    allocSize -= alignDiff;
                    result = (char *) result + alignDiff;
                }

                if (alignDiff || *size == minSize) {

                    size_t returnSize = 0x00010000lu - alignDiff;
                    void *returnAddr = (char *) result + allocSize - returnSize;

                    allocSize -= returnSize;

                    if (returnSize)
                        spaces__munmap(returnAddr, returnSize);
                }

                *size = allocSize;

            }

            return result;
        }
    }
};

Bool spaces__sysReturnM(Chunk * chunk, void *addr64, size_t *size64, unsigned flags, Bool bResize)
{
    (void)chunk;
    (void)flags;
    (void)bResize;
    return spaces__munmap((caddr_t) addr64, *size64);
};

void *spaces__sysCommitM(void *addr, size_t size)
{
    (void)size;
    return addr;
};

Bool spaces__sysDecommitM(void *addr, size_t size)
{
    (void)addr;
    (void)size;
    return 1;
};

Bool spaces__sysFreeAddressSpace(void *addr, size_t size, Bool bResize, size_t *released)
{
    (void)bResize;
    if (spaces__munmapEnabled && ((size_t) addr < spaces__heapBottom || (size_t) addr > spaces__heapTop)
        && spaces__munmap((caddr_t) addr, size)) {
        if (released)
            *released += size;
        return 1;
    }
    return 0;
};

void *spaces__sbrk(size_t usize)
{
    return sbrk((intptr_t) usize);
};

void *spaces__mmap(void *addr, size_t size, unsigned mmap_flags)
{
    static int spaces__devzero_fd = -1;
    void *result;

    if (spaces__devzero_fd == -1) {
        if ((spaces__devzero_fd = open("/dev/zero", 02)) == -1)
            return 0;
    }

    if (addr)
        mmap_flags |= 0x10;

    result = mmap(addr, size, 0x1 | 0x2 | 0x4, mmap_flags | 0x02, spaces__devzero_fd, 0);

    if (result == (void *) -1)
        return 0;

    return result;
};

Bool spaces__munmap(void *addr, size_t size)
{
    return munmap(addr, size) == 0;
};

unsigned long spaces__sysGetPageSize(void)
{
    static size_t pageSize = 0;

    if (pageSize)
        return pageSize;

    return pageSize = getpagesize();
};

typedef struct {
    SpacesChunk chunk;
    SpacesChunk nextChunk;
} SharedChunkNext;
static SharedChunkNext *_spaces__sharedChunks = 0;
static int _spaces__sharedChunkCount = 0;
int MMaxSharedChunks = 64;
static SharedChunkNext *_spaces__findNextChunk(SpacesChunk chunk);

SpacesChunk _spaces__sysAllocNamedShared(size_t size,
                                         size_t totalSize, unsigned flags, void *addr,
                                         unsigned pidCount, unsigned long *pids, void *security, const char *name)
{
    int shmid;
    struct shmid_ds shm_buf;
    AreaChunk *areaChunk;
    int shmflag = 0666;
    int shm_cmd = 2;

    (void) addr;
    (void) pidCount;
    (void) pids;

    size +=
        ((PageSize)
         ((PageSize) ((PageSize) (sizeof(Area)) + (PageSize) ((sizeof(double)) - 1u)) &
          ((PageSize) (~((PageSize) ((sizeof(double)) - 1u))))));

    if ((flags & 0x1000u)
        && size >
        (0x00010000lu -
         ((PageSize)
          ((PageSize) ((PageSize) (sizeof(Area)) + (PageSize) ((sizeof(double)) - 1u)) &
           ((PageSize) (~((PageSize) ((sizeof(double)) - 1u))))))))
        size =
            (0x00010000lu -
             ((PageSize)
              ((PageSize) ((PageSize) (sizeof(Area)) + (PageSize) ((sizeof(double)) - 1u)) &
               ((PageSize) (~((PageSize) ((sizeof(double)) - 1u)))))));

    size =
        ((unsigned long) ((unsigned long) ((unsigned long) ((size)) + (unsigned long) ((0x10000) - 1u)) &
                          ((unsigned long) (~((unsigned long) ((0x10000) - 1u))))));
    totalSize =
        ((unsigned long) ((unsigned long) ((unsigned long) ((totalSize)) + (unsigned long) ((0x10000) - 1u)) &
                          ((unsigned long) (~((unsigned long) ((0x10000) - 1u))))));

    totalSize = (((totalSize) > (4 * 64 * 1024L)) ? (totalSize) : (4 * 64 * 1024L));

    if (security)
        shmflag = *(int *) security;

    if ((shmid = shmget((key_t) name, totalSize, 01000 | 02000 | shmflag))
        == -1)
        return 0;

    areaChunk = (AreaChunk *) shmat(shmid, 0, 0);

    if (areaChunk == (void *) -1 || shmctl(shmid, shm_cmd, &shm_buf) == -1) {
        shmctl(shmid, 0, 0);
        return 0;
    }

    totalSize = (((unsigned long) ((shm_buf.shm_segsz))) & ((unsigned long) (~((unsigned long) ((0x10000) - 1u)))));

    spaces__initializeAreaChunk(areaChunk, totalSize, size);

    areaChunk->chunk.task.shared.shmid = shmid;

    return &areaChunk->chunk;
};

Bool spaces__initSharedChunk(SpacesChunk chunk, unsigned flags, void *security)
{
    (void)chunk;
    (void)flags;
    (void)security;
    return 1;
};

SpacesChunk *_spaces__getNextChunk(SpacesChunk chunk)
{
    SharedChunkNext *p = _spaces__findNextChunk(chunk);

    if (!p) {
        if (!_spaces__sharedChunks) {
            _spaces__sharedChunks =
                (SharedChunkNext *) _spaces__sysAlloc(sizeof(SharedChunkNext) * MMaxSharedChunks, 0x0100u);
            if (!_spaces__sharedChunks)
                goto err;
        }

        if (_spaces__sharedChunkCount < MMaxSharedChunks) {
            p = &_spaces__sharedChunks[_spaces__sharedChunkCount++];
            p->chunk = chunk;
            p->nextChunk = 0;
        } else
            goto err;
    }

    return &p->nextChunk;

  err:
    _spaces__invokeErrorHandler1(0, SPACES_ERR_TOO_MANY_TASKS);
    return 0;
};

void _spaces__delNextChunk(SpacesChunk chunk)
{
    SharedChunkNext *p = _spaces__findNextChunk(chunk);
    if (p)
        *p = _spaces__sharedChunks[--_spaces__sharedChunkCount];
};

static SharedChunkNext *_spaces__findNextChunk(SpacesChunk chunk)
{
    SharedChunkNext *p = _spaces__sharedChunks;
    int count = _spaces__sharedChunkCount;

    while (count--) {
        if (p->chunk == chunk)
            return p;
        p++;
    }

    return 0;
};

union semun {
    int val;
    struct semid_ds *buf;
    unsigned short *array;
};

Bool _spaces__initSharedSem(SpacesChunk chunk)
{

    int semid = semget(((__key_t) 0)
                       , 1,
                       01000 | 02000 | 0666);
    union semun su;

    if (semid == -1)
        return 0;

    su.val = 1;
    if (semctl(semid, 0, 16, su) == -1)
        return 0;

    chunk->task.shared.semid = semid;

    return 1;
};

Bool _spaces__lockSharedSem(SpacesChunk chunk)
{
    struct sembuf buf;

    buf.sem_num = 0;
    buf.sem_op = -1;
    buf.sem_flg = 04000 | 0x1000;

    if (semop(chunk->task.shared.semid, &buf, 1) == -1) {
        if ((*__errno_location())
            != 11)
            return 0;

        if (semctl(chunk->task.shared.semid, 0, 11) == getpid()
            && chunk->task.shared.threadID == _spaces__getCurrentThreadID()
            ) {
            ((chunk)->mutex.count)++;
            return 1;
        } else {
            buf.sem_flg = 0x1000;

            if (semop(chunk->task.shared.semid, &buf, 1) == -1)
                return 0;
        }
    }

    chunk->task.shared.threadID = _spaces__getCurrentThreadID();

    ((chunk)->mutex.count) = 1;
    return 1;
};

void _spaces__unlockSharedSem(SpacesChunk chunk)
{
    struct sembuf buf;

    buf.sem_num = 0;
    buf.sem_op = 1;
    buf.sem_flg = 0x1000;

    if (--((chunk)->mutex.count) == 0) {

        chunk->task.shared.threadID = 0;

        semop(chunk->task.shared.semid, &buf, 1);
    }
};

unsigned long _spaces__getCurrentProcessID()
{

    if (spaces__preInitThreads)
        return 0;

    return getpid();
};

SpacesChunk _spaces__registerShared(SpacesChunk chunk, const char *name, Bool bInit, Bool * bWasRegistered)
{
    AreaChunk *areaChunk = 0;
    int shmid;

    if (bInit) {
        if (chunk->flags & 0x0001u)
            chunk->task.shared.sharedRefCount = 1;
        return chunk;
    }

    else {
        if ((shmid = shmget((key_t) name, 0, 0)) == -1)
            return 0;

        if ((areaChunk = (AreaChunk *) shmat(shmid, 0, 0)) == (void *) -1)
            return 0;

        chunk = &areaChunk->chunk;

        if (chunk->areaChunk != areaChunk) {

            void *rightAddr = chunk->areaChunk;
            shmdt((void *) areaChunk);
            if ((areaChunk = (AreaChunk *) shmat(shmid, rightAddr, 0))
                == (void *) -1)
                return 0;

            chunk = &areaChunk->chunk;
        }

        if (chunk->task.shared.shmid != shmid) {

            goto failed;
        }

    }

    if (chunk->flags & 0x0001u) {
        if (_spaces__findNextChunk(chunk)) {

            if (bWasRegistered)
                *bWasRegistered = 1;
        } else {
            {
                if ((chunk)->flags & 0x0002u) {
                    if ((chunk)->flags & 0x0001u) {
                        if (!_spaces__lockSharedSem(chunk))
                            return 0;
                    } else { {
                            if (!(pthread_mutex_lock(&(&((chunk)->mutex))->m) == 0 && ++(&((chunk)->mutex))->count))
                                return 0;
                            if ((chunk)->mutex.count == 1) {
                                if (((chunk)->flags & 0x0002u)) { {
                                        int i___ = 2;
                                        int k___ = 0;
                                        while (!((((chunk)->lock) && spaces__test_and_clear(&(chunk)->lock)))) {;
                                            if (i___-- == 0) {
                                                spaces__smpYield(k___++);
                                                i___ = 2;
                                            }
                                        }
                                }
                                };
                            }
                    };
                    }
                }
            };

            chunk->task.shared.sharedRefCount++;

            {
                if ((chunk)->flags & 0x0002u) {
                    if ((chunk)->flags & 0x0001u)
                        _spaces__unlockSharedSem(chunk);
                    else { {
                            if ((chunk)->mutex.count == 1) { {
                                    if (((chunk)->flags & 0x0002u) && !(chunk)->locktid) {
                                        if (!spaces__preForkLock) { {
                                                if ((chunk)->smpFreeQueue)
                                                    spaces__smpFlushQueue(chunk);
                                        };
                                        }
                                        ((chunk)->lock = 1);
                                    }
                            };
                            }
                            (--(&((chunk)->mutex))->count, pthread_mutex_unlock(&(&((chunk)->mutex))->m));
                    };
                    }
                }
            };

            if (bWasRegistered)
                *bWasRegistered = 0;
        }
    }

    return chunk;

  failed:
    if (areaChunk)
        shmdt((void *) areaChunk);

    return 0;

};

int _spaces__unregisterShared(SpacesChunk chunk, Bool bTerminating)
{
    int result = 0;
    (void)bTerminating;
    int shmid = -1;
    int semid = -1;

    if (chunk->flags & 0x0001u) {
        shmid = chunk->task.shared.shmid;
        semid = chunk->task.shared.semid;

        {
            if ((chunk)->flags & 0x0002u) {
                if ((chunk)->flags & 0x0001u) {
                    if (!_spaces__lockSharedSem(chunk))
                        return -1;
                } else { {
                        if (!(pthread_mutex_lock(&(&((chunk)->mutex))->m) == 0 && ++(&((chunk)->mutex))->count))
                            return -1;
                        if ((chunk)->mutex.count == 1) {
                            if (((chunk)->flags & 0x0002u)) { {
                                    int i___ = 2;
                                    int k___ = 0;
                                    while (!((((chunk)->lock) && spaces__test_and_clear(&(chunk)->lock)))) {;
                                        if (i___-- == 0) {
                                            spaces__smpYield(k___++);
                                            i___ = 2;
                                        }
                                    }
                            }
                            };
                        }
                };
                }
            }
        };

        result = --chunk->task.shared.sharedRefCount;

        {
            if ((chunk)->flags & 0x0002u) {
                if ((chunk)->flags & 0x0001u)
                    _spaces__unlockSharedSem(chunk);
                else { {
                        if ((chunk)->mutex.count == 1) { {
                                if (((chunk)->flags & 0x0002u) && !(chunk)->locktid) {
                                    if (!spaces__preForkLock) { {
                                            if ((chunk)->smpFreeQueue)
                                                spaces__smpFlushQueue(chunk);
                                    };
                                    }
                                    ((chunk)->lock = 1);
                                }
                        };
                        }
                        (--(&((chunk)->mutex))->count, pthread_mutex_unlock(&(&((chunk)->mutex))->m));
                };
                }
            }
        };
    }

    _spaces__taskRemoveChunk(chunk);

    if (chunk->flags & 0x0001u) {

        shmdt((void *) chunk->areaChunk);

        if (result == 0) {

            semctl(semid, 0, 0, 0);
            shmctl(shmid, 0, 0);
        }
    }

    return result;
};

Bool spaces__threads_initialized = 0;
int spaces__preInitThreads = 1;

Bool spaces__preForkLock = 0;

static void spaces__pthreadPreFork(void);
static void spaces__pthreadPostForkParent(void);
static void spaces__pthreadPostForkChild(void);
pthread_mutexattr_t spaces__mutex_attr;

Bool spaces__pthread_initialized()
{
    if (!spaces__preInitThreads)
        return 1;
    if (pthread_mutexattr_init(&spaces__mutex_attr) == 0
        && pthread_mutexattr_settype(&spaces__mutex_attr, PTHREAD_MUTEX_RECURSIVE_NP) == 0) {
        SpacesChunk chunk;

        spaces__getProcessorCount();
        chunk = spaces_init_default_chunk();

        spaces__preInitThreads = 0;

        if (!spaces__initThreadLocalChunk())
            spaces__preInitThreads = 1;
        else {

            {
                if (!spaces__createAndEnterMutex(&spaces__mutexGlobal))
                    return !(spaces__preInitThreads = 1);
            };
            {
                if (!spaces__preInitThreads)
                    (--(&spaces__mutexGlobal)->count, pthread_mutex_unlock(&(&spaces__mutexGlobal)->m));
            };

            if (chunk) {
                if (((((chunk)->mutex.count) =
                      0),
                     ((chunk)->
                      flags & 0x0001u) ? _spaces__initSharedSem(chunk) : spaces__initMutex(&((chunk)->mutex)))) {
                    chunk->flags |= 0x0002u | 0x8000u;

                    if (!spaces__smpInitChunk(chunk))
                        spaces__preInitThreads = 1;
                } else
                    spaces__preInitThreads = 1;
            }
        }
    }

    return !spaces__preInitThreads;
};

Spacesi_Sys_Once_Ret spaces__initMutexGlobal(void);
Spacesi_Sys_Once_Ret spaces__initMutexMov(void);
Spacesi_Sys_Once_Ret spaces__initMutexDefchunk(void);
Spacesi_Sys_Once_Ret spaces__initMutexSMP(void);

Spacesi_Mutex spaces__mutexGlobal = {
    0, (spaces__initMutexGlobal), {{0}}, 0, 0, 0, 0
};

Spacesi_Mutex spaces__mutexMov = {
    0, (spaces__initMutexMov), {{0}}, 0, 0, 0, 0
};

Spacesi_Mutex spaces__mutexDefchunk = {
    0, (spaces__initMutexDefchunk), {{0}}, 0, 0, 0, 0
};

Spacesi_Mutex spaces__mutexSMP = {
    0, (spaces__initMutexSMP), {{0}}, 0, 0, 0, 0
};

Bool _spaces__enterCriticalSection()
{
    if (spaces__preInitThreads)
        return 1;

    return spaces__createAndEnterMutex(&spaces__mutexDefchunk);
};

void _spaces__leaveCriticalSection()
{
    if (!spaces__preInitThreads && spaces__mutexDefchunk.bInit)
        (--(&spaces__mutexDefchunk)->count, pthread_mutex_unlock(&(&spaces__mutexDefchunk)->m));
};

static Bool bDisableAtForkHandlers = 0;
void spaces_process_disable_fork_handlers()
{
    bDisableAtForkHandlers = 1;
};

Bool spaces__createAndEnterMutex(Spacesi_Mutex * mutex)
{
    static Bool bPthreadForkHandlersInstalled = 0;

    if (spaces__preInitThreads)
        return 1;

    if (!bPthreadForkHandlersInstalled) {
        bPthreadForkHandlersInstalled = 1;

        if (!bDisableAtForkHandlers) {
            if (pthread_atfork(spaces__pthreadPreFork, spaces__pthreadPostForkParent,
                               spaces__pthreadPostForkChild) != 0) {
                bPthreadForkHandlersInstalled = 0;
                return 0;
            }
        }
    }

    if (!mutex->bInit) {

        static struct {
            ThreadID thread;
            Spacesi_Mutex *m;
        } recurse;

        if (recurse.m == mutex && recurse.thread == pthread_self())
            return 1;
        else
            recurse.m = mutex, recurse.thread = pthread_self();

        if (!(pthread_once(&mutex->once, mutex->initFn) == 0) || !mutex->bInit)
            return 0;

        recurse.m = 0, recurse.thread = 0;
    }

    return (pthread_mutex_lock(&(mutex)->m) == 0 && ++(mutex)->count);
};

Bool spaces__mutex_trylock(Spacesi_Mutex * mutex)
{
    if (pthread_mutex_trylock(&mutex->m) == 0) {
        mutex->owner = pthread_self();
        mutex->count++;

        return 1;
    } else if (mutex->owner == pthread_self()) {

        mutex->count++;
        return 1;
    }

    return 0;
};

Spacesi_Sys_Once_Ret spaces__initMutexGlobal()
{
    spaces__threads_initialized = 1;
    spaces__initMutex(&spaces__mutexGlobal);
};

Spacesi_Sys_Once_Ret spaces__initMutexMov()
{
    spaces__initMutex(&spaces__mutexMov);
};

Spacesi_Sys_Once_Ret spaces__initMutexDefchunk()
{
    spaces__initMutex(&spaces__mutexDefchunk);
};

Spacesi_Sys_Once_Ret spaces__initMutexSMP()
{
    spaces__initMutex(&spaces__mutexSMP);
};

Bool spaces__initMutex(Spacesi_Mutex * mutex)
{
    Bool bResult;

    bResult = pthread_mutex_init(&mutex->m, &spaces__mutex_attr) == 0;
    if (bResult) {
        mutex->bInit = 1;
        mutex->count = 0;
        mutex->owner = 0;
    }

    return bResult;
};

static void spaces__pthreadPreFork(void)
{
    if (spaces_default_chunk) {
        SpacesChunk chunk = spaces_init_default_chunk();

        spaces__preForkLock = 1;

        {
            if ((chunk)->smpParent)
                (chunk) = (chunk)->smpParent;
            do {
                chunk->savedFreeBytes = chunk->freeBytes;
                chunk->freeBytes = (0x7fffffffffffffffL * 2UL + 1UL);
            } while (((chunk) = (chunk)->smpNextChunk) != 0 && (chunk) != (chunk)->smpParent);
        }


        spaces_chunk_lock(chunk);

        {
            if ((chunk)->smpParent)
                (chunk) = (chunk)->smpParent;
            do {;
            } while (((chunk) = (chunk)->smpNextChunk) != 0 && (chunk) != (chunk)->smpParent);
        }

    }

    {
        if (!spaces__createAndEnterMutex(&spaces__mutexGlobal))
            return;
    };
};

static void spaces__pthreadPostForkParent(void)
{
    {
        if (!spaces__preInitThreads)
            (--(&spaces__mutexGlobal)->count, pthread_mutex_unlock(&(&spaces__mutexGlobal)->m));
    };

    if (spaces__preForkLock) {
        SpacesChunk chunk = spaces_init_default_chunk();

        {
            if ((chunk)->smpParent)
                (chunk) = (chunk)->smpParent;
            do {
                chunk->freeBytes = chunk->savedFreeBytes;
            } while (((chunk) = (chunk)->smpNextChunk) != 0 && (chunk) != (chunk)->smpParent);
        }


        spaces_chunk_unlock(chunk);
        spaces__preForkLock = 0;
    }
};

static void spaces__pthreadPostForkChild(void)
{
    SpacesChunk chunk;

    spaces__initMutex(&spaces__mutexGlobal);
    spaces__initMutex(&spaces__mutexMov);
    spaces__initMutex(&spaces__mutexSMP);
    spaces__initMutex(&spaces__mutexDefchunk);

    chunk = spaces_init_default_chunk();

    {
        if ((chunk)->smpParent)
            (chunk) = (chunk)->smpParent;
        do {
            ((((chunk)->mutex.count) =
              0), ((chunk)->flags & 0x0001u) ? _spaces__initSharedSem(chunk) : spaces__initMutex(&((chunk)->mutex)));
            ((chunk)->lock = 1);
            ((chunk)->locktid = 0);
            chunk->freeBytes = chunk->savedFreeBytes;
        } while (((chunk) = (chunk)->smpNextChunk) != 0 && (chunk) != (chunk)->smpParent);
    }


    spaces__preForkLock = 0;
};

Bool spaces__bSMP = -1;
static int spaces__nLogicalProcessors = -1;

Bool spaces__getLinuxCpuInfo(int *packages, int *cores, int *processors);

int spaces__getProcessorCount()
{
    static int cpus = 0;

    if (cpus)
        return cpus;

    {
        int packages, cores, processors;

        if (spaces__getLinuxCpuInfo(&packages, &cores, &processors)) {
            cpus = processors;
            spaces__bSMP = (packages > 2);
            spaces__nLogicalProcessors = processors / cores;
        } else
            cpus = get_nprocs();
    }

    if (spaces__bSMP == -1)
        spaces__bSMP = (cpus > 2);

    if (spaces__nLogicalProcessors == -1)
        spaces__nLogicalProcessors = 1;

    return cpus;
};

static int spaces__count_occurrences(char *p, char *s);

Bool spaces__getLinuxCpuInfo(int *packages, int *cores, int *processors)
{

    FILE *pFile;
    long lSize;
    char *buffer;
    size_t result;

    pFile = fopen("/proc/cpuinfo", "rb");

    if (pFile == 0)
        return 0;

    lSize = sysconf(_SC_PAGESIZE);

    buffer = (char *) _spaces__sysAlloc(sizeof(char) * lSize, 0);
    if (buffer == 0) {
        fclose(pFile);
        return 0;
    }

    result = fread(buffer, 1, lSize, pFile);
    if (result != (size_t)lSize && !feof(pFile)) {
        fclose(pFile);
        return 0;
    }

    fclose(pFile);

    *processors = spaces__count_occurrences(buffer, "processor");
    *packages = spaces__count_occurrences(buffer, "physical id");
    *cores = spaces__count_occurrences(buffer, "core id");

    if (*processors == 0)
        *processors = 1;
    if (*packages == 0)
        *packages = *processors;
    if (*cores == 0)
        *cores = *processors;

    _spaces__sysFree(buffer);

    return 1;
};

static int spaces__count_occurrences(char *p, char *s)
{
    int count = 0;
    long ids[256];

    while ((p = strstr(p, s)) != 0) {

        p += strlen(s);

        while (((*__ctype_b_loc())[(int) ((*p))] & (unsigned short int) _ISspace)
            ) {
            p++;
        }

        if (*p++ == ':') {
            int i = count;
            long id = strtol(p, 0, 0);

            while (i--) {
                if (ids[i] == id)
                    goto nextLabel;
            }

            ids[count++] = id;
        }

      nextLabel:
    }

    return count;
};

pthread_key_t spaces__tlsChunk;
static Bool spaces__bTlsChunkInit = 0;

static void spaces__threadTermFn(void *x);
static void spaces__threadTermFn(void *x)
{
    spaces__freeThreadExcChunk((Chunk *) x, 0);
};

ThreadLocalChunk spaces__threadLocalChunks[997] = { 0 };

Bool spaces__initThreadLocalChunk()
{
    if (spaces__preInitThreads)
        return 0;

    if (pthread_key_create(&spaces__tlsChunk, spaces__threadTermFn) == 0)
        spaces__bTlsChunkInit = 1;

    return spaces__bTlsChunkInit;
};

Bool spaces__setThreadLocalChunk(Chunk * chunk, Bool bExclusive)
{
    Bool bSetTLP = 0;

    if (chunk && bExclusive) {

        if (spaces__preInitThreads || !spaces__bTlsChunkInit)
            return 0;

        if (pthread_setspecific(spaces__tlsChunk, chunk) == 0)
            bSetTLP = 1;
        else
            return 0;
    }

    {
        ThreadLocalChunk *thrChunk;

        thrChunk = &spaces__threadLocalChunks[pthread_self() % 997];

        if (!chunk) {

            thrChunk->chunk = 0;
            thrChunk->tid = 0;
        } else if (thrChunk->chunk == 0) {

            thrChunk->chunk = chunk;
            thrChunk->tid = pthread_self();
        } else {

            if (thrChunk->tid == pthread_self())
                thrChunk->chunk = chunk;
            else {

                if (bSetTLP)
                    pthread_setspecific(spaces__tlsChunk, 0);

                return 0;
            }
        }

        return 1;
    }
};

ThreadID _spaces__getCurrentThreadID()
{
    if (spaces__preInitThreads)
        return 0;
    {

        return pthread_self();

    }
};

SpacesiThread spaces__getCurrentThread()
{

    return pthread_self();
};

void spaces__smpYield(unsigned count)
{
    if (count)
        usleep(count);
    else {
        sched_yield();

    }
};

Bool spaces__runThread(void (*fn)(void *), void *arg, ThreadHandle * result)
{
    ThreadHandle hThread;

    pthread_t tid;

    if (pthread_create(&tid, 0, (void *(*)(void *)) fn, arg) == -1)
        return 0;

    hThread = (ThreadHandle) tid;

    if (result)
        *result = hThread;

    return 1;
};

void spaces__setThreadPriority(ThreadHandle tid, int prio)
{

    struct sched_param sp;

    sp.sched_priority = prio;

    pthread_setschedparam((pthread_t) tid, 0, &sp);
};

void spaces__sleepThread(unsigned milliseconds)
{
    (void)milliseconds;
    sched_yield();
};

jmp_buf spaces__env;
extern void *end, *etext, *edata;

Bool _spaces__sysValidatePtr(void *ptr, size_t len, unsigned flags)
{
    Bool bHeapPtr = 0;

    if (!ptr)
        return 0;

    if (flags & (0x0200 | 0x0800 | 0x0100 | 0x1000 | 0x2000)) {
        bHeapPtr = 1;

        if (!((size_t) ((size_t) ptr & ((size_t) ((sizeof(void *)) - 1u))) == (size_t) 0u))
            return 0;
    }

    {

        if (bHeapPtr) {
            if ((size_t) ptr >= spaces__heapBottom
                && (size_t) ptr < spaces__heapTop
                && (size_t) ptr <= (size_t) ptr + len && (size_t) ptr + len < spaces__heapTop)
                return 1;
        }
    }

    return 0;
};

Bool _spaces__sysValidateFunction(VoidFn fn)
{

    return fn != 0;
};

pthread_cond_t spaces__eventPageCache = { { { 0}, { 0}, { 0, 0}, { 0, 0}, 0, 0, { 0, 0}
                                            }
};

static pthread_mutex_t lock = { { 0, 0, 0, 0, PTHREAD_MUTEX_TIMED_NP, 0, 0, { 0, 0} } };

void *ptr_spacesi_eventPageCache;

Bool spaces__createEventPageCache()
{
    int ret;
    pthread_mutex_lock(&lock);
    ret = pthread_cond_init(&spaces__eventPageCache, 0);
    pthread_mutex_unlock(&lock);
    if (ret == 0) {
        ptr_spacesi_eventPageCache = &spaces__eventPageCache;
        return 1;
    }
    return 0;

};

Bool spaces__deleteEventPageCache()
{
    if (ptr_spacesi_eventPageCache) {
        (void)pthread_cond_destroy(&spaces__eventPageCache);
    }
    return 1;
};

Bool spaces__waitForEventPageCache()
{
    int ret;

    pthread_mutex_lock(&lock);
    ret = pthread_cond_wait(&spaces__eventPageCache, &lock);
    pthread_mutex_unlock(&lock);
    if (ret == 0) {
        return 1;
    } else {
        return 0;
    }
    return 1;
};

Bool spaces__signalEventPageCache()
{
    int ret;
    ret = pthread_cond_signal(&spaces__eventPageCache);
    if (ret == 0) {
        return 1;
    }
    return 0;
};

static spaces_global_t g_spaces;
static volatile int g_init_state = 0;
static spaces_spinlock_t g_init_lock = 0;
static __thread spaces_heap_t *tl_heap = 0;
static pthread_key_t g_heap_key;
static volatile int g_key_created = 0;

static void init_size_classes(void)
{
    int idx = 0;
    uint32_t sz;
    for (sz = 8; sz <= 128 && idx < 64; sz += 8)
        g_spaces.classes[idx++].size = sz;
    for (sz = 160; sz <= 512 && idx < 64; sz += 32)
        g_spaces.classes[idx++].size = sz;
    for (sz = 640; sz <= 2048 && idx < 64; sz += 128)
        g_spaces.classes[idx++].size = sz;
    for (sz = 2560; sz <= (8 * 1024) && idx < 64; sz += 512)
        g_spaces.classes[idx++].size = sz;

    g_spaces.num_classes = idx;

    for (int i = 0; i < idx; i++) {
        uint32_t s = g_spaces.classes[i].size;
        g_spaces.classes[i].slab_capacity = (uint32_t) (((1UL << 16) - 4096) / s);
        if (s <= 256) {
            g_spaces.classes[i].cache_max = 512;
            g_spaces.classes[i].cache_drain = 512 / 2;
        } else if (s <= 1024) {
            g_spaces.classes[i].cache_max = 128;
            g_spaces.classes[i].cache_drain = 128 / 2;
        } else {
            g_spaces.classes[i].cache_max = 32;
            g_spaces.classes[i].cache_drain = 32 / 2;
        }
    }

    memset(g_spaces.small_class_lookup, 0, sizeof(g_spaces.small_class_lookup));
    for (uint32_t s = 0; s <= (8 * 1024); s += 8) {
        int ci = 0;
        while (ci < idx && g_spaces.classes[ci].size < s)
            ci++;
        if (ci >= idx)
            ci = idx - 1;
        g_spaces.small_class_lookup[s / 8] = (uint8_t) ci;
    }
};

static inline __attribute__((always_inline))
int size_to_class(size_t size)
{
    if (__builtin_expect(!!(size <= (8 * 1024)), 1)) {
        uint32_t r = (uint32_t) ((size + 7) & ~7);
        if (__builtin_expect(!!(r == 0), 0))
            r = 8;
        return g_spaces.small_class_lookup[r >> 3];
    }
    return -1;
};

static void *os_mmap(size_t size, int use_huge)
{
    int flags = 0x02 | 0x20;

    if (use_huge && size >= (2UL * 1024 * 1024)) {
        void *p = mmap(0, size,
                       0x1 | 0x2, flags | 0x40000, -1, 0);
        if (p != ((void *) -1)
            )
            return p;
    }

    void *p = mmap(0, size,
                   0x1 | 0x2, flags, -1, 0);
    return (p == ((void *) -1)
        )? 0 : p;
};

static void os_munmap(void *p, size_t sz)
{
    munmap(p, sz);
};

static spaces_spinlock_t g_seg_lock = 0;
static char *g_seg_next = 0;
static char *g_seg_end = 0;

static void *alloc_segment(void)
{
    spaces_spin_lock(&g_seg_lock);
    if (g_seg_next < g_seg_end) {
        char *r = g_seg_next;
        g_seg_next += (1UL << 16);
        spaces_spin_unlock(&g_seg_lock);
        return r;
    }
    size_t alloc = ((1UL << 16) * 64) + (1UL << 16);
    char *p = (char *) os_mmap(alloc, 0);
    if (!p) {
        spaces_spin_unlock(&g_seg_lock);
        return 0;
    }
    uintptr_t a = ((uintptr_t) p + (1UL << 16) - 1) & (~((1UL << 16) - 1));
    char *base = (char *) a;
    size_t head = (size_t) (base - p);
    if (head)
        os_munmap(p, head);
    size_t usable = alloc - head;
    size_t region = (usable / (1UL << 16)) * (1UL << 16);
    size_t tail = usable - region;
    if (tail)
        os_munmap(base + region, tail);
    g_seg_next = base + (1UL << 16);
    g_seg_end = base + region;
    spaces_spin_unlock(&g_seg_lock);
    return base;
};

static spaces_slab_t *slab_create(int ci)
{
    spaces_slab_t *slab;
    spaces_lfnode_t *node = spaces_lfstack_pop(&g_spaces.empty_slabs);
    if (node) {
        slab = (spaces_slab_t *) node;
    } else {
        slab = (spaces_slab_t *) alloc_segment();
        if (!slab)
            return 0;
    }
    memset(slab, 0, sizeof(spaces_slab_t));
    slab->magic = 0x5350414Eu;
    slab->size_class = (uint8_t) ci;
    slab->state = 1;
    slab->obj_size = g_spaces.classes[ci].size;
    slab->capacity = (uint16_t) g_spaces.classes[ci].slab_capacity;
    slab->bump_offset = 4096;
    slab->owner = tl_heap;
    return slab;
};

static void slab_return_empty(spaces_slab_t * slab)
{
    slab->state = 0;
    slab->local_free = 0;
    slab->owner = 0;
    spaces_lfstack_push(&g_spaces.empty_slabs, (spaces_lfnode_t *) slab);
};

static inline __attribute__((always_inline))
void *slab_alloc(spaces_slab_t * slab)
{
    if (slab->local_free) {
        spaces_lfnode_t *n = slab->local_free;
        slab->local_free = n->next;
        slab->alloc_count++;
        return (void *) n;
    }
    uint32_t off = slab->bump_offset;
    uint32_t end = 4096 + (uint32_t) slab->capacity * slab->obj_size;
    if (off < end) {
        void *ptr = (char *) slab + off;
        slab->bump_offset = off + slab->obj_size;
        slab->alloc_count++;
        return ptr;
    }
    return 0;
};

static inline __attribute__((always_inline))
int slab_alloc_bulk(spaces_slab_t * slab, spaces_lfnode_t ** chain, int max)
{
    int n = 0;
    spaces_lfnode_t *head = 0;
    while (n < max) {
        void *obj = slab_alloc(slab);
        if (!obj)
            break;
        spaces_lfnode_t *node = (spaces_lfnode_t *) obj;
        node->next = head;
        head = node;
        n++;
    }
    *chain = head;
    return n;
};

static inline __attribute__((always_inline))
int slab_drain_remote(spaces_slab_t * slab)
{
    spaces_lfnode_t *chain = spaces_lfstack_take_all(&slab->remote_free);
    if (!chain)
        return 0;
    int c = 0;
    while (chain) {
        spaces_lfnode_t *nx = chain->next;
        chain->next = slab->local_free;
        slab->local_free = chain;
        chain = nx;
        c++;
    }
    return c;
};

static void thread_heap_destructor(void *arg);

static void ensure_global_init(void)
{
    if (__builtin_expect(!!(__atomic_load_n(&(g_init_state), 0) == 2), 1))
        return;
    spaces_spin_lock(&g_init_lock);
    if (g_init_state == 0) {
        g_init_state = 1;
        g_spaces.os_page_size = (int) sysconf(_SC_PAGESIZE);
        g_spaces.num_cpus = (int) sysconf(_SC_NPROCESSORS_ONLN);
        if (g_spaces.num_cpus < 1)
            g_spaces.num_cpus = 1;
        g_spaces.has_hugepages = 0;

        {
            void *p = mmap(0, (2UL * 1024 * 1024),
                           0x1 | 0x2,

                           0x02 | 0x20 | 0x40000, -1, 0);
            if (p != ((void *) -1)
                ) {
                munmap(p, (2UL * 1024 * 1024));
                g_spaces.has_hugepages = 1;
            }
        }

        init_size_classes();
        for (int i = 0; i < 64; i++)
            spaces_lfstack_init(&g_spaces.central_partial[i]);
        spaces_lfstack_init(&g_spaces.empty_slabs);
        g_spaces.heap_pool_lock = 0;
        g_spaces.heap_pool_free = 0;
        g_spaces.initialized = 1;
        __atomic_store_n(&(g_init_state), (2), 3);
    }
    spaces_spin_unlock(&g_init_lock);
    while (__atomic_load_n(&(g_init_state), 2) != 2)
        __asm__ volatile ("pause":::"memory");
};

static spaces_heap_t *heap_alloc(void)
{
    spaces_spin_lock(&g_spaces.heap_pool_lock);
    spaces_heap_t *h = g_spaces.heap_pool_free;
    if (h)
        g_spaces.heap_pool_free = h->next_free;
    spaces_spin_unlock(&g_spaces.heap_pool_lock);

    if (h) {

        memset(h->active, 0, sizeof(h->active));
        memset(h->partial_slabs, 0, sizeof(h->partial_slabs));
        h->initialized = 1;
        h->next_free = 0;
        return h;
    }

    size_t hsz = (sizeof(spaces_heap_t) + 63) & ~63;
    size_t batch = 16;
    size_t total = hsz * batch;
    total = (total + 4095) & ~4095;
    char *block = (char *) os_mmap(total, 0);
    if (!block)
        return 0;

    h = (spaces_heap_t *) block;
    h->initialized = 1;

    spaces_spin_lock(&g_spaces.heap_pool_lock);
    for (size_t i = 1; i < batch && (i * hsz + sizeof(spaces_heap_t)) <= total; i++) {
        spaces_heap_t *x = (spaces_heap_t *) (block + i * hsz);
        x->next_free = g_spaces.heap_pool_free;
        g_spaces.heap_pool_free = x;
    }
    spaces_spin_unlock(&g_spaces.heap_pool_lock);
    return h;
};

static void heap_return(spaces_heap_t * h)
{
    spaces_spin_lock(&g_spaces.heap_pool_lock);
    h->next_free = g_spaces.heap_pool_free;
    g_spaces.heap_pool_free = h;
    spaces_spin_unlock(&g_spaces.heap_pool_lock);
};

static spaces_heap_t *get_thread_heap(void)
{
    if (__builtin_expect(!!(tl_heap != 0), 1))
        return tl_heap;
    ensure_global_init();
    if (!__atomic_load_n(&(g_key_created), 0)) {
        spaces_spin_lock(&g_init_lock);
        if (!g_key_created) {
            pthread_key_create(&g_heap_key, thread_heap_destructor);
            __atomic_store_n(&(g_key_created), (1), 3);
        }
        spaces_spin_unlock(&g_init_lock);
    }
    spaces_heap_t *heap = heap_alloc();
    if (!heap)
        return 0;
    tl_heap = heap;
    pthread_setspecific(g_heap_key, heap);
    return heap;
};

static void heap_flush(spaces_heap_t * heap)
{
    for (int c = 0; c < g_spaces.num_classes; c++) {
        spaces_cache_bin_t *bin = &heap->bins[c];
        spaces_lfnode_t *node = bin->head;
        while (node) {
            spaces_lfnode_t *nx = node->next;
            spaces_slab_t *slab = ((spaces_slab_t *) ((uintptr_t) (node) & (~((1UL << 16) - 1))));
            if (slab->owner == heap) {
                node->next = slab->local_free;
                slab->local_free = node;
                if (__atomic_sub_fetch(&(slab->alloc_count), (1), 4) == 0) {
                    if (heap->active[c] == slab)
                        heap->active[c] = 0;
                    slab_return_empty(slab);
                }
            } else {
                spaces_lfstack_push(&slab->remote_free, node);
                __atomic_fetch_sub(&(slab->alloc_count), (1), 0);
            }
            node = nx;
        }
        bin->head = 0;
        bin->count = 0;

        spaces_slab_t *as = heap->active[c];
        if (as) {
            as->owner = 0;
            if (__atomic_load_n(&(as->alloc_count), 0) == 0)
                slab_return_empty(as);
            else
                spaces_lfstack_push(&g_spaces.central_partial[c], (spaces_lfnode_t *) as);
            heap->active[c] = 0;
        }
        spaces_slab_t *ps = heap->partial_slabs[c];
        while (ps) {
            spaces_slab_t *nx = ps->next;
            ps->owner = 0;
            if (__atomic_load_n(&(ps->alloc_count), 0) == 0)
                slab_return_empty(ps);
            else
                spaces_lfstack_push(&g_spaces.central_partial[c], (spaces_lfnode_t *) ps);
            ps = nx;
        }
        heap->partial_slabs[c] = 0;
    }
};

static void thread_heap_destructor(void *arg)
{
    spaces_heap_t *heap = (spaces_heap_t *) arg;
    if (!heap)
        return;
    heap_flush(heap);
    tl_heap = 0;
    heap_return(heap);
};

static int central_refill(spaces_heap_t * heap, int ci)
{
    spaces_cache_bin_t *bin = &heap->bins[ci];

    spaces_lfnode_t *sn = spaces_lfstack_pop(&g_spaces.central_partial[ci]);
    if (sn) {
        spaces_slab_t *slab = (spaces_slab_t *) sn;
        slab->owner = heap;
        slab_drain_remote(slab);
        spaces_lfnode_t *chain = 0;
        int filled = slab_alloc_bulk(slab, &chain, 64);
        if (filled > 0) {

            spaces_lfnode_t *tail = chain;
            while (tail->next)
                tail = tail->next;
            tail->next = bin->head;
            bin->head = chain;
            bin->count += filled;
        }
        if (slab->bump_offset < 4096 + (uint32_t) slab->capacity * slab->obj_size || slab->local_free)
            heap->active[ci] = slab;
        else
            slab->state = 2;
        return filled;
    }
    return 0;
};

static void cache_drain(spaces_heap_t * heap, int ci)
{
    spaces_cache_bin_t *bin = &heap->bins[ci];
    int target = (int) g_spaces.classes[ci].cache_drain;
    while (bin->count > target && bin->head) {
        spaces_lfnode_t *node = bin->head;
        bin->head = node->next;
        bin->count--;
        spaces_slab_t *slab = ((spaces_slab_t *) ((uintptr_t) (node) & (~((1UL << 16) - 1))));
        if (slab->owner == heap) {
            node->next = slab->local_free;
            slab->local_free = node;
            if (__atomic_sub_fetch(&(slab->alloc_count), (1), 4) == 0 && slab != heap->active[ci])
                slab_return_empty(slab);
        } else {
            spaces_lfstack_push(&slab->remote_free, node);
            __atomic_fetch_sub(&(slab->alloc_count), (1), 0);
        }
    }
};

static __attribute__((noinline))
void *small_malloc_slow(spaces_heap_t * heap, int ci)
{
    spaces_cache_bin_t *bin = &heap->bins[ci];

    spaces_slab_t *slab = heap->active[ci];
    if (slab) {
        if (!spaces_lfstack_empty(&slab->remote_free))
            slab_drain_remote(slab);
        spaces_lfnode_t *chain = 0;
        int n = slab_alloc_bulk(slab, &chain, 64);
        if (n > 0) {

            spaces_lfnode_t *first = chain;
            chain = chain->next;
            first->next = 0;
            if (chain) {
                spaces_lfnode_t *tail = chain;
                while (tail->next)
                    tail = tail->next;
                tail->next = bin->head;
                bin->head = chain;
                bin->count += n - 1;
            }
            return (void *) first;
        }

        if (__atomic_load_n(&(slab->alloc_count), 0) > 0)
            slab->state = 2;
        else
            slab_return_empty(slab);
        heap->active[ci] = 0;
    }

    slab = heap->partial_slabs[ci];
    if (slab) {
        heap->partial_slabs[ci] = slab->next;
        slab_drain_remote(slab);
        heap->active[ci] = slab;
        void *obj = slab_alloc(slab);
        if (obj)
            return obj;
    }

    if (central_refill(heap, ci) > 0) {
        spaces_lfnode_t *n = bin->head;
        bin->head = n->next;
        bin->count--;
        return (void *) n;
    }

    slab = slab_create(ci);
    if (!slab)
        return 0;
    heap->active[ci] = slab;

    spaces_lfnode_t *chain = 0;
    int filled = slab_alloc_bulk(slab, &chain, 64 + 1);
    if (filled <= 0)
        return 0;

    spaces_lfnode_t *first = chain;
    chain = chain->next;
    first->next = 0;
    if (chain) {
        spaces_lfnode_t *tail = chain;
        while (tail->next)
            tail = tail->next;
        tail->next = bin->head;
        bin->head = chain;
        bin->count += filled - 1;
    }
    return (void *) first;
};

static __attribute__((hot))
void small_free(void *ptr, spaces_slab_t * slab)
{
    spaces_heap_t *heap = tl_heap;
    if (__builtin_expect(!!(heap && slab->owner == heap), 1)) {
        int ci = slab->size_class;
        spaces_cache_bin_t *bin = &heap->bins[ci];
        if (__builtin_expect(!!(bin->count < (int32_t) g_spaces.classes[ci].cache_max), 1)) {
            spaces_lfnode_t *node = (spaces_lfnode_t *) ptr;
            node->next = bin->head;
            bin->head = node;
            bin->count++;
            return;
        }
        cache_drain(heap, ci);
        spaces_lfnode_t *node = (spaces_lfnode_t *) ptr;
        node->next = bin->head;
        bin->head = node;
        bin->count++;
        return;
    }

    spaces_lfstack_push(&slab->remote_free, (spaces_lfnode_t *) ptr);
    uint32_t rem = __atomic_sub_fetch(&(slab->alloc_count), (1), 4);
    if (rem == 0 && slab->owner == 0) {
        uint8_t exp = 2;
        if (__atomic_compare_exchange_n(&(slab->state), &(exp), (0), 0, 4, 2)) {
            slab_drain_remote(slab);
            slab_return_empty(slab);
        } else {
            exp = 1;
            if (__atomic_compare_exchange_n(&(slab->state), &(exp), (0), 0, 4, 2)) {
                slab_drain_remote(slab);
                slab_return_empty(slab);
            }
        }
    }
};

static void *large_malloc(size_t size)
{
    size_t total = (size + 4096 + 4095) & ~4095;
    int use_huge = (g_spaces.has_hugepages && total >= (2UL * 1024 * 1024));
    if (use_huge)
        total = (total + (2UL * 1024 * 1024) - 1) & ~((2UL * 1024 * 1024) - 1);
    size_t alloc = total + (1UL << 16);
    char *base = (char *) os_mmap(alloc, use_huge);
    if (!base)
        return 0;
    uintptr_t a = ((uintptr_t) base + (1UL << 16) - 1) & (~((1UL << 16) - 1));
    char *sb = (char *) a;
    size_t head = (size_t) (sb - base);
    if (head)
        os_munmap(base, head);
    size_t tail_off = head + total;
    if (tail_off < alloc)
        os_munmap(base + tail_off, alloc - tail_off);
    spaces_slab_t *slab = (spaces_slab_t *) sb;
    memset(slab, 0, sizeof(spaces_slab_t));
    slab->magic = 0x5350414Eu;
    slab->state = 3;
    slab->size_class = 0xFF;
    slab->mmap_size = total;
    slab->mmap_base = sb;
    slab->alloc_count = 1;
    slab->capacity = 1;
    return sb + 4096;
};

static void large_free(spaces_slab_t * slab)
{
    os_munmap(slab->mmap_base, slab->mmap_size);
};

static size_t large_usable_size(spaces_slab_t * slab, void *ptr)
{
    return slab->mmap_size - ((uintptr_t) ptr - (uintptr_t) slab);
};

void *spaces_memalign(size_t alignment, size_t size)
{
    ensure_global_init();
    if (alignment == 0 || (alignment & (alignment - 1)) != 0)
        return 0;
    if (alignment <= 16)
        return spaces_malloc(size);

    if (size == 0)
        size = 1;
    size_t eff = (size + alignment - 1) & ~(alignment - 1);
    if (eff < alignment)
        eff = alignment;
    int ci = size_to_class(eff);
    if (ci >= 0) {
        uint32_t os = g_spaces.classes[ci].size;
        if (os % alignment == 0 && 4096 % alignment == 0)
            return spaces_malloc(eff);
    }

    size_t hdr = 4096;
    size_t total = hdr + alignment + size;
    total = (total + 4095) & ~4095;
    size_t alloc = total + (1UL << 16);
    char *base = (char *) os_mmap(alloc, 0);
    if (!base)
        return 0;
    uintptr_t seg = ((uintptr_t) base + (1UL << 16) - 1) & (~((1UL << 16) - 1));
    char *sb = (char *) seg;
    size_t head = (size_t) (sb - base);
    if (head)
        os_munmap(base, head);
    if (head + total < alloc)
        os_munmap(base + head + total, alloc - head - total);
    uintptr_t user = (seg + hdr + alignment - 1) & ~(alignment - 1);
    spaces_slab_t *slab = (spaces_slab_t *) sb;
    memset(slab, 0, sizeof(spaces_slab_t));
    slab->magic = 0x5350414Eu;
    slab->state = 3;
    slab->size_class = 0xFF;
    slab->obj_size = (uint32_t) (user - seg);
    slab->mmap_size = total;
    slab->mmap_base = sb;
    slab->alloc_count = 1;
    slab->capacity = 1;
    return (void *) user;
};

void spaces_core_init(void)
{
    ensure_global_init();
};

static __attribute__((noinline))
void *spaces_malloc_slow(size_t size)
{
    ensure_global_init();
    if (__builtin_expect(!!(size <= (8 * 1024)), 1)) {
        spaces_heap_t *heap = tl_heap;
        if (__builtin_expect(!!(!heap), 0)) {
            heap = get_thread_heap();
            if (!heap)
                return 0;
        }
        int ci = size_to_class(size);
        if (__builtin_expect(!!(ci < 0), 0))
            return 0;
        return small_malloc_slow(heap, ci);
    }
    return large_malloc(size);
};

void * __attribute__((hot)) spaces_malloc(size_t size)
{
    if (__builtin_expect(!!(size == 0), 0))
        size = 1;

    if (__builtin_expect(!!(size <= (8 * 1024)), 1)) {
        spaces_heap_t *heap = tl_heap;
        if (__builtin_expect(!!(heap != 0), 1)) {
            int ci = size_to_class(size);
            if (__builtin_expect(!!(ci >= 0), 1)) {
                spaces_cache_bin_t *bin = &heap->bins[ci];
                spaces_lfnode_t *head = bin->head;
                if (__builtin_expect(!!(head != 0), 1)) {
                    bin->head = head->next;
                    bin->count--;
                    return (void *) head;
                }
            }
        }
    }
    return spaces_malloc_slow(size);
};

static __attribute__((noinline))
void spaces_free_slow(void *ptr, spaces_slab_t * slab)
{
    if (__builtin_expect(!!(slab->state == 3), 0)) {
        large_free(slab);
        return;
    }
    small_free(ptr, slab);
};

void __attribute__((hot)) spaces_free(void *ptr)
{
    if (__builtin_expect(!!(!ptr), 0))
        return;
    spaces_slab_t *slab = ((spaces_slab_t *) ((uintptr_t) (ptr) & (~((1UL << 16) - 1))));

    if (__builtin_expect(!!(slab->magic == 0x5350414Eu), 1)) {
        spaces_heap_t *heap = tl_heap;
        if (__builtin_expect(!!(heap != 0 && slab->owner == heap && slab->state != 3), 1)
            ) {
            int ci = slab->size_class;
            spaces_cache_bin_t *bin = &heap->bins[ci];
            if (__builtin_expect(!!(bin->count < (int32_t) g_spaces.classes[ci].cache_max), 1)) {
                spaces_lfnode_t *node = (spaces_lfnode_t *) ptr;
                node->next = bin->head;
                bin->head = node;
                bin->count++;
                return;
            }
        }
        spaces_free_slow(ptr, slab);
    }
};

void *spaces_calloc(size_t nobj, size_t size)
{
    size_t total;
    if (nobj && size) {
        total = nobj * size;
        if (total / nobj != size)
            return 0;
    } else
        total = 0;
    void *p = spaces_malloc(total);
    if (p) {
        spaces_slab_t *slab = ((spaces_slab_t *) ((uintptr_t) (p) & (~((1UL << 16) - 1))));
        if (!(slab->magic == 0x5350414Eu && slab->state == 3))
            memset(p, 0, total);

    }
    return p;
};

void *spaces_realloc(void *ptr, size_t size)
{
    if (!ptr)
        return spaces_malloc(size);
    if (size == 0) {
        spaces_free(ptr);
        return 0;
    }
    spaces_slab_t *slab = ((spaces_slab_t *) ((uintptr_t) (ptr) & (~((1UL << 16) - 1))));
    if (__builtin_expect(!!(slab->magic != 0x5350414Eu), 0))
        return 0;
    if (slab->state != 3) {
        uint32_t os = slab->obj_size;
        if (__builtin_expect(!!(size <= os), 1))
            return ptr;
        void *np = spaces_malloc(size);
        if (!np)
            return 0;
        memcpy(np, ptr, os);
        spaces_free(ptr);
        return np;
    } else {
        size_t old = large_usable_size(slab, ptr);
        if (size <= old)
            return ptr;
        void *np = spaces_malloc(size);
        if (!np)
            return 0;
        memcpy(np, ptr, old);
        spaces_free(ptr);
        return np;
    }
};

size_t spaces_usable_size(void *ptr)
{
    if (!ptr)
        return 0;
    spaces_slab_t *slab = ((spaces_slab_t *) ((uintptr_t) (ptr) & (~((1UL << 16) - 1))));
    if (slab->magic != 0x5350414Eu)
        return 0;
    if (slab->state == 3)
        return large_usable_size(slab, ptr);
    return slab->obj_size;
};

void spaces_thread_cleanup(void)
{
    if (tl_heap)
        thread_heap_destructor(tl_heap);
};

int spaces_malloc_linked = 1;

void *malloc(size_t size)
{
    return spaces_malloc(size);
};

void *calloc(size_t nobj, size_t siz)
{
    return spaces_calloc(nobj, siz);
};

void *realloc(void *p, size_t size)
{
    return spaces_realloc(p, size);
};

void free(void *p)
{
    spaces_free(p);
};

void *memalign(size_t alignment, size_t size)
{
    return spaces_memalign(alignment, size);
};

void *aligned_alloc(size_t alignment, size_t size)
{
    if (alignment == 0 || (alignment & (alignment - 1)) != 0)
        return 0;
    return spaces_memalign(alignment, size);
};

int posix_memalign(void **memptr, size_t alignment, size_t size)
{
    if (alignment % sizeof(void *) != 0)
        return 22;
    if (alignment == 0 || (alignment & (alignment - 1)) != 0)
        return 22;
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wnonnull-compare"
    if (!memptr)
        return 22;
#pragma GCC diagnostic pop

    void *p = spaces_memalign(alignment, size);
    if (!p)
        return 12;

    *memptr = p;
    return 0;
};

void *__libc_memalign(size_t alignment, size_t size)
{
    return memalign(alignment, size);
};

void *valloc(size_t size)
{
    static int page_size = 0;
    if (!page_size) {
        page_size = getpagesize();
    }
    return memalign(page_size, size);
};

int mallopt(int command, int value)
{
    (void) command;
    (void) value;
    return 0;
};

struct mallinfo mallinfo(void)
{
    static struct mallinfo info;
    return info;
};

size_t malloc_usable_size(void *ptr)
{
    return spaces_usable_size(ptr);
};